建造者模式

写程序时候，可能需要建立一个很复杂的类，但是希望把类和其构造函数拆分开，由多个构造函数一起组成这个类就叫做建造者模式。

参考文档：https://juejin.im/post/5bebafee6fb9a049cd53bf5b
参考文档：http://c.biancheng.net/view/1354.html

建造者模式核心思想是把 要构造的类型 和 构造函数 分开，利用多个其他的小构造函数不断的构造这个复杂的类型
复杂类型需要保证产品的组成类型必须相同，相对的优点是可以构建多个建造者，并且建造者可以相互组合，比写构造函数方便的多

类似于配电脑，需要配置cpu，显示器，内存
可以分成如下几个类：
    main类：客户端，用户可以直接在这里输入参数，就构建好了电脑类型
    产品类：电脑的类型，包括了电脑的各种参数
    抽象建造者：所有具体建造者的父类，在这里写了几个抽象的 cpu，显示器，内存，规定所有具体的建造者，都必须要构建这几个东西
    具体建造者：抽象建造者的具体实现，可以有多个，也可以由多个进行组合
    指挥者：mian类型直接调用指挥者，指挥者调用具体建造者，构建出产品类，并进行返还

具体如下：

主函数，相当于客户端，调用指挥者来构建类型

package builderDemo;

public class CreateComputer {
    /**
     * 参考文档：https://juejin.im/post/5bebafee6fb9a049cd53bf5b
     * 参考文档：http://c.biancheng.net/view/1354.html
     *
     * 建造者模式核心思想是把 要构造的类型 和 构造函数 分开，利用多个其他的小构造函数不断的构造这个复杂的类型
     * 复杂类型需要保证产品的组成类型必须相同，相对的优点是可以构建多个建造者，并且建造者可以相互组合，比写构造函数方便的多
     *
     * 类似于配电脑，需要配置cpu，显示器，内存
     * 可以分成如下几个类：
     *      main类：客户端，用户可以直接在这里输入参数，就构建好了电脑类型
     *      产品类：电脑的类型，包括了电脑的各种参数
     *      抽象建造者：所有具体建造者的父类，在这里写了几个抽象的 cpu，显示器，内存，规定所有具体的建造者，都必须要构建这几个东西
     *      具体建造者：抽象建造者的具体实现，可以有多个，也可以由多个进行组合
     *      指挥者：mian类型直接调用指挥者，指挥者调用具体建造者，构建出产品类，并进行返还
     *
     * @param args
     */
    public static void main(String[] args) {
        Builder mBuilder = new MoonComputerBuilder();
        Director mDirector = new Director(mBuilder);
        //组装计算机，result就是组装好的计算机类型
        Computer result = mDirector.CreateComputer("i7-6700", "华擎玩家至尊", "三星 DDR4");
    }
}

产品类：

package builderDemo;

public class Computer {

    private String mCpu;
    private String mMainboard;
    private String mRam;

    public void setmCpu(String mCpu) {
        this.mCpu = mCpu;
    }

    public void setmMainboard(String mMainboard) {
        this.mMainboard = mMainboard;
    }

    public void setmRam(String mRam) {
        this.mRam = mRam;
    }

}

抽象建造者：

public abstract class Builder {
    public abstract void buildCpu(String cpu);
    public abstract void buildMainboard(String mainboard);
    public abstract void buildRam(String ram);
    public abstract Computer create();
}

具体建造者（可以有多个，只要继承了Builder即可）：

package builderDemo;

public class MoonComputerBuilder extends Builder {
    private Computer mComputer = new Computer();
    @Override
    public void buildCpu(String cpu) {
        mComputer.setmCpu(cpu);
    }

    @Override
    public void buildMainboard(String mainboard) {
        mComputer.setmMainboard(mainboard);
    }

    @Override
    public void buildRam(String ram) {
        mComputer.setmRam(ram);
    }

    @Override
    public Computer create() {
        return mComputer;
    }


}

指挥者：

package builderDemo;

public class Director {
    Builder mBuild = null;

    public Director(Builder build) {
        this.mBuild = build;
    }

    public Computer CreateComputer(String cpu, String mainboard, String ram) {
        //规范建筑流程
        this.mBuild.buildMainboard(mainboard);
        this.mBuild.buildCpu(cpu);
        this.mBuild.buildRam(ram);
        return mBuild.create();
    }
}