设计模式觉醒系列(03)创建型模式的5个设计模式 | 一口气讲全讲透

package lading.java.designpattern.builder;
public class Computer {
    private String cpu;
    private String memory;
    private String storage;
    private String mainBoard;

    //避免其他地方实例化
    private Computer() {

    }

    public String getCpu() {
        return cpu;
    }

    public String getMemory() {
        return memory;
    }

    public String getStorage() {
        return storage;
    }

    public String getMainBoard() {
        return mainBoard;
    }

    @Override
    public String toString() {
        return "Computer{" +
                "cpu='" + cpu + '\'' +
                ", memory='" + memory + '\'' +
                ", storage='" + storage + '\'' +
                ", mainBoard='" + mainBoard + '\'' +
                '}';
    }

    //建造者builder
    public static class Builder {
        private Computer computer = new Computer();

        public Builder setCpu(String cpu) {
            computer.cpu = cpu;
            return this;
        }

        public Builder setMemory(String memory) {
            computer.memory = memory;
            return this;
        }

        public Builder setStorage(String storage) {
            computer.storage = storage;
            return this;
        }

        public Builder setMainBoard(String mainBoard) {
            computer.mainBoard = mainBoard;
            return this;
        }

        public Computer build() {
            //这里还可以定义一些步骤去组织实例化该对象。。。
            return computer;
        }
    }

}

package lading.java.designpattern.builder;

/**
 * 客户端调用，无需关注Computer对象的内部细节，
 * 构建Computer只需要通过它的建造者 Computer.Builder()去处理。
 */
public class ClientDemo {
    public static void main(String[] args) {
        Computer computer  = new Computer.Builder().setStorage("磁盘xx")
                .setCpu("cpu xx").setMainBoard("主板xx").setMemory("内存xx")
                .build();
        System.out.println(computer.toString());
    }
}

package lading.java.designpattern.prototype;

import java.util.ArrayList;
import java.util.List;

/**
 * 一个用户
 * 名字
 * 衣柜的衣服，有多件衣服
 */
public class User implements Cloneable {
    private String name;
    //衣柜的衣服
    private List<String> cloths;

    public User(String name, List<String> cloths) {
        this.name = name;
        this.cloths = cloths;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", cloths=" + cloths +
                '}';
    }

    //浅拷贝
    @Override
    public User clone() throws CloneNotSupportedException {
        return (User) super.clone();
    }

    public User deepClone() throws CloneNotSupportedException {
        User newUser = (User) super.clone();
        //对引用对象，递归复制克隆
        newUser.cloths = new ArrayList<>(this.cloths);
        return newUser;
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        List<String> cloths = new ArrayList<>();
        cloths.add("衬衫");
        cloths.add("裤子");
        User sourceUser = new User("拉丁解牛", cloths);
        System.out.println("原始对象值：" + sourceUser);
        //浅拷贝deepCopy
        User shallowCopy = sourceUser.clone();
        //深拷贝deepCopy
        User deepCopy = sourceUser.deepClone();
        //在原始对象里新增T恤
        sourceUser.cloths.add("T恤");
        //浅拷贝对象同样被污染
        System.out.println("浅拷贝的对象被污染，多了一个T恤：" + shallowCopy);
        System.out.println("浅拷贝的对象没有被污染，保持和原对象一致：" + deepCopy);
    }
}

package lading.java.designpattern.factorymethod;

/**
 * 抽象工厂类
 */
public abstract class AbstractComputerFactory {
    //定义工厂抽象方法，生产电脑
    abstract IComputer createComputer();
    //定义一些公共功能，让子类复用
    void init(){
        System.out.println("工厂初始化");
    }
}

package lading.java.designpattern.factorymethod;

public interface IComputer {
    //生产电脑
    void produce(String computerName);
}

package lading.java.designpattern.factorymethod;

/**
 * 具体的工厂子类
 */
public class AppleComputerFactory extends AbstractComputerFactory {
    @Override
    public IComputer createComputer() {
        return new AppleComputer();
    }
}

package lading.java.designpattern.factorymethod;

/**
 * 具体的产品类
 */
public class AppleComputer implements IComputer{
    @Override
    public void produce(String computerName) {
        System.out.println("苹果电脑工厂，开始生产："+computerName);
    }
}

package lading.java.designpattern.factorymethod;

public class FactoryMethodClientDemo {
    public static void main(String[] args) {
        //实例化具体苹果工厂子类
        AbstractComputerFactory computerFactory = new AppleComputerFactory();
        //复用工厂初始化操作
        computerFactory.init();
        //通过苹果工厂去生产苹果电脑
        IComputer appleComputer = computerFactory.createComputer();
        appleComputer.produce("macBook Pro");
    }
}

package lading.java.designpattern.abstractfactory;

/**
 * 工厂接口，支持生产不同种类的产品
 * 具体的生产线（品牌），在子类中实现
 */
public interface IFactory {
    //生产电脑
    IComputer makeComputer();
    //生产手机
    IMobilePhone makePhone();
}

package lading.java.designpattern.abstractfactory;

/**
 * 不同类型产品，定义为接口
 * 电脑生产线
 */
public interface IComputer {
    void produce();
}

package lading.java.designpattern.abstractfactory;

/**
 * 手机生产线，生产手机产品
 */
public interface IMobilePhone {
    void produce();
}

package lading.java.designpattern.abstractfactory;

/**
 * 具体工厂子类（具体品牌）
 * 华为工厂，生产具体的电脑、手机
 */
public class HuaweiFactory implements IFactory{
    @Override
    public IComputer makeComputer() {
        //生成自己品牌对象
        return new HuaweiComputer();
    }

    @Override
    public IMobilePhone makePhone() {
        //生成自己品牌对象
        return new HuaweiMobilePhone();
    }
}

package lading.java.designpattern.abstractfactory;

public class HuaweiMobilePhone implements IMobilePhone{
    @Override
    public void produce() {
        System.out.println("生产华为手机");
    }
}

package lading.java.designpattern.abstractfactory;

/**
 * 华为品牌，生产有电脑和手机
 */
public class HuaweiComputer implements IComputer{
    @Override
    public void produce() {
        System.out.println("生产华为电脑");
    }
}

package lading.java.designpattern.abstractfactory;

/**
 * 抽象工厂demo客户端
 */
public class AbstractFactoryDemo {
    public static void main(String[] args) {
        //华为工厂,生产手机、电脑
        IFactory factory = new HuaweiFactory();
        factory.makeComputer().produce();
        factory.makePhone().produce();
        //如果新增其他品牌，新增对应xxFactory。
        //如果生产线内部修改，只需要改自己内部对客户端无影响
    }
}