建造者模式

建造者模式
将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

1. builder（抽象建造者）：给出一个抽象结论，以规范产品对象的各个组成成分的建造。这个接口规定要实现复杂对象的那些部分的创建，并不涉及具体的对象部件的创建。
2. ConcreteBuilder（具体建造者）：实现Builder接口，针对不同的商业逻辑，具体化复杂对象的各部分的创建。在构造过程完成后，提供产品的实例。
3. Director（导演）：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。
4. Product（产品类）：要创建的复杂对象。

建造者：创建和提供实例，导演：管理建造出来的实例的依赖关系。

与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。（导演管理建造出来的实例的依赖关系）

如果说抽象工厂模式是提供建造一系列相关对象的工厂的话，
建造者模式提供构建一个复杂对象的构建过程，除了提供对各个零件的构建方法，更注重零件装配的配置和顺序

---

各个零件

public interface CPU {
    String toString();
}
public class Intel implements CPU{

    public Intel(String name) {
        this.name = name;
    }

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String toString(){

        return name;
    }
}

public class CMD implements CPU {
    public CMD(String name) {
        this.name = name;
    }

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String toString(){
        return name;
    }
}

public class Bluetooth {

    public Bluetooth(String name) {
        this.name = name;
    }

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class Memory {

    public Memory(String name) {
        this.name = name;
    }

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

---

产品类

public class Computer {
    private CPU cpu;
    private Memory memory;
    private Bluetooth bluetooth;

    public CPU getCpu() {
        return cpu;
    }

    public void setCpu(CPU cpu) {
        this.cpu = cpu;
    }

    public Memory getMemory() {
        return memory;
    }

    public void setMemory(Memory memory) {
        this.memory = memory;
    }

    public Bluetooth getBluetooth() {
        return bluetooth;
    }

    public void setBluetooth(Bluetooth bluetooth) {
        this.bluetooth = bluetooth;
    }
}

---

建造者

public interface Builder {
    void buildCPU(CPU cpu);
    void buildMemory(Memory memory);
    void buildBluetooth(Bluetooth bluetooth);
    Computer getComputer();
}

public class ComputerBuilder implements Builder{

    Computer computer = null;

    public ComputerBuilder() {
        computer = new Computer();
    }

    @Override
    public void buildCPU(CPU cpu) {
        computer.setCpu(cpu);
    }

    @Override
    public void buildMemory(Memory memory) {
        computer.setMemory(memory);
    }

    @Override
    public void buildBluetooth(Bluetooth bluetooth) {
        computer.setBluetooth(bluetooth);
    }

    @Override
    public Computer getComputer() {
        return computer;
    }
}

---

导演

public class ComputerDirector {
    public Computer constructComputer(Builder builder) {

        builder.buildCPU(new Intel("intel"));
        builder.buildMemory(new Memory("memory"));
        builder.buildBluetooth(new Bluetooth("bluetooth"));

        return builder.getComputer();
    }
    public Computer constructComputer2(Builder builder) {

        builder.buildCPU(new CMD("CMD"));
        builder.buildMemory(new Memory("memory"));
        builder.buildBluetooth(new Bluetooth("bluetooth"));

        return builder.getComputer();
    }

    public static void main(String[] args) {
        Builder builder = new ComputerBuilder();
        ComputerDirector director = new ComputerDirector();
        Computer computer = director.constructComputer(builder);
        System.out.println(computer.getCpu().toString());
        Computer computer2 = director.constructComputer2(builder);
        System.out.println(computer2.getCpu().toString());
    }
}