建造者模式(创建型设计模式)

一、建造者模式介绍和应用场景

建造者模式（Builder Pattern）

• 使⽤多个简单的对象⼀步⼀步构建成⼀个复杂的对象， 将⼀个复杂对象的构建与它的表示分离，使得同样的构 建过程可以创建不同的表示 允许⽤户只通过指定复杂对象的类型和内容就可以构建它们，不需要知道内部的具体构建细节 

核心组成 

• Builder：抽象建造者，定义多个通⽤⽅法和构建⽅法
• ConcreteBuilder：具体建造者，可以有多个
• Director：指挥者，控制整个组合过程，将需求交给建造者，由建造者去创建对象
• Product：产品⻆⾊ 

二、优缺点

优点：

• 客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦
• 每⼀个具体建造者都相对独⽴，⽽与其他的具体建造者⽆关，更加精细地控制产品的创建过程 增加新的具体建造者⽆须修改原有类库的代码，符合开闭原则
• 建造者模式结合链式编程来使⽤，代码上更加美观

缺点： 

• 建造者模式所创建的产品⼀般具有较多的共同点，如果 产品差异⼤则不建议使⽤ 

建造者模式与抽象工厂模式的比较 

• 建造者模式返回⼀个组装好的完整产品 ， 抽象⼯⼚模式返回⼀系列相关的产品，这些产品位于不同的产品等级结构，构成了⼀个产品族 

三、代码实现 

/**
 * 产品
 */
public class Computer {
    private String cpu;
    private String disk;
    private String power;
    private String memory;
    private String mainBoard;

    public Computer() {
    }

    public Computer(String cpu, String disk, String power, String memory, String mainBoard) {
        this.cpu = cpu;
        this.disk = disk;
        this.power = power;
        this.memory = memory;
        this.mainBoard = mainBoard;
    }

    public String getCpu() {
        return cpu;
    }

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

    public String getDisk() {
        return disk;
    }

    public void setDisk(String disk) {
        this.disk = disk;
    }

    public String getPower() {
        return power;
    }

    public void setPower(String power) {
        this.power = power;
    }

    public String getMemory() {
        return memory;
    }

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

    public String getMainBoard() {
        return mainBoard;
    }

    public void setMainBoard(String mainBoard) {
        this.mainBoard = mainBoard;
    }

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

/**
 * 抽象建造者，声明了建造者的公共方法
 */
public interface Builder {
    void buildCpu();
    void buildMainBoard();
    void buildDisk();
    void buildPower();
    void buildMemory();
    Computer createComputer();
}

/**
 * 低配具体建造
 */
public class LowComputerBuilder implements Builder{
    private Computer computer = new Computer();
    @Override
    public void buildCpu() {
        computer.setCpu("垃圾CPU");
    }

    @Override
    public void buildMainBoard() {
        computer.setMainBoard("垃圾主板");
    }

    @Override
    public void buildDisk() {
        computer.setDisk("垃圾磁盘");
    }

    @Override
    public void buildPower() {
        computer.setPower("垃圾电源");
    }

    @Override
    public void buildMemory() {
        computer.setMemory("垃圾内存");
    }

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

/**
 * 高级具体建造
 */
public class AdvancedComputerBuilder implements Builder{
    private Computer computer = new Computer();
    @Override
    public void buildCpu() {
        computer.setCpu("高级CPU");
    }

    @Override
    public void buildMainBoard() {
        computer.setMainBoard("高级主板");
    }

    @Override
    public void buildDisk() {
        computer.setDisk("高级磁盘");
    }

    @Override
    public void buildPower() {
        computer.setPower("高级电源");
    }

    @Override
    public void buildMemory() {
        computer.setMemory("高级内存");
    }

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

/**
 * 调度者，将产品和创建的过程解耦，使用相同的创建过程创建出不同的产品，控制产品生产过程
 * Director时全程知道组装过程，具体细节还是builder去操作
 */
public class Director {
    public Computer create(Builder builder){
        builder.buildCpu();
        builder.buildMainBoard();
        builder.buildDisk();
        builder.buildPower();
        builder.buildMemory();
        return builder.createComputer();
    }
}

public class Main {
    public static void main(String[] args) {
        Director director = new Director();
        Builder lBuilder = new LowComputerBuilder();
        Computer lowComputer = director.create(lBuilder);
        System.out.println(lowComputer);

        Builder advancedBuilder = new AdvancedComputerBuilder();
        Computer AComputer = director.create(advancedBuilder);
        System.out.println(AComputer);
    }
}

注释：个人学习观点以作笔记，有瑕疵望谅解