设计模式（创建型）---建造者模式

概述

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

核心构成

1.Builder：抽象建造者，定义多个通用方法和构建方法
2.ConcreteBuilder：具体建造者，实现Builder接口，可以有多个
3.Director：指挥者，控制建造流程，并交给具体建造者，由具体建造者去创建对象
4.Product：产品，需要被建造的类

举例说明

以手机为例

/**
 * 产品
 */
public class Phone {

    //cpu
    private String cpu;

    //内存
    private String memory;

    //电池
    private String battery;

    //相机
    private String camera;

    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 getBattery() {
        return battery;
    }

    public void setBattery(String battery) {
        this.battery = battery;
    }

    public String getCamera() {
        return camera;
    }

    public void setCamera(String camera) {
        this.camera = camera;
    }

    @Override
    public String toString() {
        return "Phone{" +
                "cpu='" + cpu + '\'' +
                ", memory='" + memory + '\'' +
                ", battery='" + battery + '\'' +
                ", camera='" + camera + '\'' +
                '}';
    }
}

抽象建造者

/**
 * 抽象建造者
 */
public interface Builder {

    void buildCpu();

    void buildMemory();

    void buildBattery();

    void buildCamera();

    Phone createPhone();

}

具体建造者，实现抽象建造者接口

public class ApplePhoneBuilder implements Builder{

    private Phone phone = new Phone();

    @Override
    public void buildCpu() {
        phone.setCpu("A14处理器");
    }

    @Override
    public void buildMemory() {
        phone.setMemory("4GB内存");
    }

    @Override
    public void buildBattery() {
        phone.setMemory("2000mAh电池");
    }

    @Override
    public void buildCamera() {
        phone.setCamera("原画相机");
    }

    @Override
    public Phone createPhone() {
        return phone;
    }
}

指挥者，定义一个create方法，入参是抽象建造者类型的变量，调用具体建造者的构建方法返回建造好的对象

/**
 * 指挥者
 */
public class Director {

    public Phone create(Builder builder){

        builder.buildCpu();
        builder.buildMemory();
        builder.buildBattery();
        builder.buildCamera();

        return builder.createPhone();
    }
}

测试

public class BuilderTest {
    public static void main(String[] args) {
        Phone applePhone = new Director().create(new ApplePhoneBuilder());
        System.out.println(applePhone.toString());
    }
}

输出

优点

封装性好，构建和表示分离。
扩展性好，各个具体的建造者相互独立，有利于系统的解耦。
可以对创建过程逐步细化，而不对其它模块产生任何影响。

缺点

产品的组成部分必须相同，限制了使用范围。