建造者模式（创建型）

建造者模式 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示
角色和职责

角色	职责
Builder	抽象建造者为创建产品各个部分，统一抽象接口
ConcreteBuilder	具体建造者具体的创建产品各个部分，部分A，部分B，部分C定义并明确它所创建的表示
Director	指挥者构造一个使用Builder接口的对象它主要是用于创建一个复杂的对象。它主要有两个作用，一是：隔离了客户与对象的生产过程，二是：负责控制产品对象的生产过程。
Product	产品角色表示被创建的的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程包含定义组成部件的类，包括将这些部件装配成最终产品的接口权

结构示例图如下：

实例
1抽象建造者

public abstract class Builder {

    //先构建一个自行车对象，此时该自行车还没有安装车架，车座等
    protected Bike bike = new Bike();

    //构建车架，
    public abstract void buildFrame();
    //构建车座
    public abstract void buildSeat();

    public abstract void setName();

    public  Bike createBike(){
        return bike;
    }

2. 具体建造者

public class HaluoBikeBuilder extends Builder {
    @Override
    public void buildFrame() {
        System.out.println("创建哈罗单车的车架");
        bike.setFrame("哈罗蓝色不锈钢车架");
    }

    @Override
    public void buildSeat() {
        bike.setName("哈罗单车");

    }

    @Override
    public void setName() {
        System.out.println("创建哈罗单车的车座");
        bike.setSeat("哈罗橡胶座椅");

    }
}

3. 构造指挥者

public class Director {

    //聚合建造者
    Builder builder ;
    public Director( Builder builder){
        this.builder = builder;
    }
    //组装自行车
    public Bike constructBike(){
        builder.buildFrame();
        builder.buildSeat();
        builder.setName();
        return builder.createBike();
    }
}

4. 产品类

public class Bike {

    //车架
    private String frame;
    //车座
    private String seat;

    private String name;

    public String getFrame() {
        return frame;
    }

    public void setFrame(String frame) {
        this.frame = frame;
    }

    public String getSeat() {
        return seat;
    }

    public void setSeat(String seat) {
        this.seat = seat;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

测试

public class test {

    public static void main(String[] args) {
        //声明具体的建造者
        Builder builder = new HaluoBikeBuilder();
        //构建指挥者
        Director director = new Director(builder);
        //组装自行车
        Bike bike = director.constructBike();
        System.out.println(bike.getName());
    }
}

扩充（简单构建模式，省略构造指挥者）
当一个类构造器需要传入很多参数时，如果创建这个类的实例，代码可读性会非常差，而且很容易引入错误，此时就可以利用简单建造者模式进行重构。同时也可以避免重载出错的问题
实例如下：

public class Phone {

     String cpu;
     String screen;
     String memory;
     String mainboard;

    private Phone(Builder builder){
        this.cpu = builder.cpu;
        this.screen = builder.screen;
        this.memory = builder.memory;
        this.mainboard = builder.mainboard;
    }

    public Phone() {
    }

    //用静态内部类的方式声明建造者
    public static class Builder extends Phone{

        public Builder() {
            super();
        }


        //链式编程
        public Builder cup(String cpu){
            this.cpu = cpu;
            return this;
        }
        public Builder screen(String screen){
            this.screen = screen;
            return this;
        }
        public Builder memory(String memory){
            this.memory = memory;
            return this;
        }
        public Builder mainboard(String mainboard){
            this.mainboard = mainboard;
            return this;
        }
        //构建手机
        public Phone build(){
            return new Phone(this);
        }
    }

    public String getCpu() {
        return cpu;
    }

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

    public String getScreen() {
        return screen;
    }

    public void setScreen(String screen) {
        this.screen = screen;
    }

    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 class test {

    public static void main(String[] args) {
        Phone phone = new Phone.Builder().cup("Amd").screen("LED").mainboard("华硕").memory("金士顿").build();
        System.out.println(phone.getCpu());
    }