创建型设计模式-建造者模式学习笔记

建造者模式（Builder Pattern）

        使用多个简单的对象一步步建成一个复杂的对象，将一个复杂对象的构建与它的分离，使得同样的构建过程可以创建不同的表示。

        允许用户只通过指定复杂对象的类型和内容就可以构建它们，不需要知道内部的具体构建细节。

核心组成：

Builder:抽象建造者，定义多个通用方法和构建方法。

ConcreteBuilder:具体建造者，可以有多个。

Director:指挥官，控制整个组合过程，将需求交给建造者，由建造者对象。

Product:产品角色。

 优点

1.客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦。

2.每一个具体建造者都相对独立，而与其他的具体建造者无关，更加精细地控制产品的创建过程。

3.增加新的具体建造者无须修改原有类库的代码，符合开闭原则。

4.建造者模式结合链式编程来使用，代码上更加美观。

缺点:建造者模式所创建的产品一般具有较多的共同点，如果产品差异大则不建议使用。

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

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

电脑低中高配场景代码演示：

package top.chenxiky.builder;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: chenxiky
 * @Date: 2022/05/08/21:44
 * @Description:
 */
public class Computer {

    private String cpu;
    private String memory; //内存
    private String mainboard; // 主板
    private String disk; // 磁盘
    private String power; // 电源


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

    public String getCpu() {
        return cpu;
    }

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

    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;
    }

    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;
    }
}



package top.chenxiky.builder;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: chenxiky
 * @Date: 2022/05/08/21:47
 * @Description: 声明了建造者的公共方法
 */

public interface ComputerBuilder {

    //TODO细节方法
    /**
     * cpu
     */
    void builderCpu();

    /**
     * 内存
     */
    void builderMemory();

    /**
     * 主板
     */
    void builderMainboard();

    /**
     * 磁盘
     */
    void builderDisk();

    /**
     * 电源
     */
    void builderPower();

    /**
     * 产品
     */
    Computer createComputer();

}

package top.chenxiky.builder;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: chenxiky
 * @Date: 2022/05/08/21:58
 * @Description: 具体的建造者，实现builder来创建不同的产品
 */
public class HighComputerBuilder implements ComputerBuilder{
    // 实例化电脑
    private  Computer computer = new Computer();
    @Override
    public void builderCpu() {
        computer.setCpu("高配CPU");
    }

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

    @Override
    public void builderMainboard() {
        computer.setMainboard("高配主板");
    }

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

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

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


package top.chenxiky.builder;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: chenxiky
 * @Date: 2022/05/08/21:53
 * @Description: 具体的建造者，实现builder来创建不同的产品
 */
public class LowComputerBuilder implements ComputerBuilder{

    // 实例化电脑
    private  Computer computer = new Computer();
    @Override
    public void builderCpu() {
        computer.setCpu("低配CPU");
    }

    @Override
    public void builderMemory() {
        computer.setMemory("低配内存");
    }

    @Override
    public void builderMainboard() {
        computer.setMainboard("低配主板");
    }

    @Override
    public void builderDisk() {
        computer.setDisk("低配磁盘");
    }

    @Override
    public void builderPower() {
        computer.setPower("低配电源");
    }

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

package top.chenxiky.builder;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: chenxiky
 * @Date: 2022/05/08/22:00
 * @Description: 将产品和创建过程进行解耦，使用相同的创建过程创建不同的产品，控制生成过程。
 * Director是全程指导组装过程，具体的细节还是具体的xxbuilder去操作的
 */
public class ComputerDirector {

    public Computer create(ComputerBuilder computerBuilder){
        computerBuilder.builderCpu();
        computerBuilder.builderMemory();
        computerBuilder.builderMainboard();
        computerBuilder.builderDisk();
        computerBuilder.builderPower();

        return computerBuilder.createComputer();
    }
}

package top.chenxiky.builder;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: chenxiky
 * @Date: 2022/05/08/22:08
 * @Description:
 */
public class Main {
    public static void main(String[] args) {
        ComputerDirector director = new ComputerDirector();

        Computer lowcomputer = director.create(new LowComputerBuilder());
        Computer highcomputer = director.create(new HighComputerBuilder());

        System.out.println(lowcomputer);
        System.out.println(highcomputer);
    }
}