建造者模式使用场景：
1.当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方法时。
2.相同的方法，不同的执行顺序，产生不同的事件结果时。
3.多个部件或零件都可以被装配到一个对象中，但是产生的运行结果又不相同的时候。
4.产品类非常复杂时，或者产品类中的调用顺序 不同面产生了不同的效能。
5.在创建一些复杂的对象时，这些对象的内部组成构件间的建行顺序 是稳定的，但对象的内部组成构件面临着复杂的变化。

优点：
1.使用建造者模式可以使用客户端不必知道产品内部的细节。
2.具体的建造者之间是相互独立的，容易扩展。
3.由于具体的建造者是独立的，因此可以对建造者过程逐步细化，而不对其他的模块产生任何影响。
缺点：
产生多余的Build对象以及你导演类

创建产品类：

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

创建Builder规范产品的组建

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

实现抽象类

public class MoonComputerBuilder extends Builder {

    Computer computer = new Computer();

    @Override
    public void buildCpu(String cpu) {
        computer.setmCpu(cpu);
    }

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

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

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

创建导演类 来规范整体流程

public class Direcror {

    Builder builder =  null;

    public Direcror(Builder builder) {
        this.builder = builder;
    }


    public Computer CreateComputer(String cpu,String mainboard,String mRam) {
        builder.buildCpu(cpu);
        builder.buildMainboard(mainboard);
        builder.buildRam(mRam);
        return builder.create();
    }
}

具体使用

    Builder builder = new MoonComputerBuilder();
        Direcror direcror = new Direcror(builder);
        direcror.CreateComputer("aaa","bbb","ccc");