1.建造者模式（简述与场景）

建造者模式
将产品与构造过程分离

举例场景：组装汽车
1.一个产品类，汽车（存在多个属性：底盘、车身、车轮、引擎、其他、品牌）
2.一个抽象构造者类，内部组合一个产品
3.一个实现类，实现抽象构造者，组装车辆
4.一般形式：构造者类通过返回 builder()对象，然后一串链式调用，最后 .build() 返回对象

框架中的应用：
1.JDK : StringBuffer(线程安全) StringBuilder
2.Guava : 里的不可变对象
3.MyBatis : SqlSessionFactoryBuild 里的双层 Builder( XMLConfigBuilder() )

2.场景代码实现

2.1.汽车（产品）

/**
 * 产品
 */
public class Car {
    //    底盘
    public String chassis = "未知";
    //    车身
    public String body = "未知";
    //    车轮
    public String wheel = "未知";
    //    引擎
    public String engine = "未知";
    //    其他
    public String other = "未知";
    //    品牌
    public String brand = "未知";

    @Override
    public String toString() {
        return "Car{" +
                "chassis='" + chassis + '\'' +
                ", body='" + body + '\'' +
                ", wheel='" + wheel + '\'' +
                ", engine='" + engine + '\'' +
                ", other='" + other + '\'' +
                ", brand='" + brand + '\'' +
                '}';
    }
}

2.2.构造者抽象类（建造者）

/**
 * 抽象构造汽车流程
 */
public abstract class AbstractCarBuilder {

    Car car = new Car();

    /**
     * 安装 底盘
     */
    abstract AbstractCarBuilder buildChassis(String str);

    /**
     * 安装 车身
     */
    abstract AbstractCarBuilder buildBody(String str);

    /**
     * 安装 车轮
     */
    abstract AbstractCarBuilder buildWheel(String str);

    /**
     * 安装 引擎
     */
    abstract AbstractCarBuilder buildEngine(String str);

    /**
     * 安装 其他
     */
    abstract AbstractCarBuilder buildOther(String str);

    /**
     * 贴 品牌
     */
    abstract AbstractCarBuilder buildBrand(String str);

    /**
     * 返回产品
     */
    abstract Car build();
}

2.3.构造者实现（建造者）

/**
 * 建造者实现类
 */
public class JBCarBuilder extends AbstractCarBuilder {

    /**
     * 安装 底盘
     */
    @Override
    JBCarBuilder buildChassis(String str) {
        this.car.chassis = str;
        return this;
    }

    /**
     * 安装 车身
     */
    @Override
    JBCarBuilder buildBody(String str) {
        this.car.body = str;
        return this;

    }

    /**
     * 安装 车轮
     */
    @Override
    JBCarBuilder buildWheel(String str) {
        this.car.wheel = str;
        return this;

    }

    /**
     * 安装 引擎
     */
    @Override
    JBCarBuilder buildEngine(String str) {
        this.car.engine = str;
        return this;

    }

    /**
     * 安装 其他
     */
    @Override
    JBCarBuilder buildOther(String str) {
        this.car.other = str;
        return this;

    }

    /**
     * 贴 品牌
     */
    @Override
    JBCarBuilder buildBrand(String str) {
        this.car.brand = str;
        return this;
    }

    /**
     * 生成产品
     */
    @Override
    Car build() {
        if (this.car.chassis.equals("未知")) {
            System.out.println("警告：生产失败。失败原因：未安装车身....");
            return null;
        }
        //        ...
        //        ...
        //        ...
        //        ...
        return this.car;
    }

}

2.4.客户端调用

/**
 * 建造者模式
 * 将产品与构造过程分离
 * <p>
 * 举例：组装汽车
 * 1.一个产品类，汽车（存在多个属性：底盘、车身、车轮、引擎、其他、品牌）
 * 2.一个抽象构造者类，内部组合一个产品
 * 3.一个实现类，实现抽象构造者，组装车辆
 * 4.一般形式：构造者类通过返回 builder()对象，然后一串链式调用，最后 .build() 返回对象
 * <p>
 * 框架中的应用：
 * StringBuffer(线程安全) StringBuilder
 * Guava 里的不可变对象
 * MyBatis 的 SqlSessionFactoryBuild 里的 双层 Builder( XMLConfigBuilder() )
 */
public class _Test {

    public static void main(String[] args) {

        //创建构造者
        JBCarBuilder jbCarBuilder =
                new JBCarBuilder()
                        .buildChassis("JB底盘")
                        .buildBody("JB专用车身")
                        .buildWheel("JB车轮")
                        .buildEngine("JB引擎")
                        .buildOther("随便找点零件")
                        .buildBrand("J B");

        jbCarBuilder.buildOther("JB专用零件");

        Car build = jbCarBuilder.build();

        System.out.println(build.toString());


        //类比StringBuilder
        StringBuilder sb =
                new StringBuilder()
                        .append("123")
                        .append("2")
                        .append("3");

        String s = sb.toString();

        System.out.println(s);


    }
}