建造者模式笔记

建造者（Builder）模式的定义：指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示
建造者模式的4个角色：
 1. Product(产品)
 2. Builder(抽象构建者)：创建一个产品Product对象的各个部件指定的接口/抽象类
 3. ConcreteBuilder(具体构建者)：实现接口，构建和装配各个部件
 4. Director(指挥者)：构建一个使用Builder接口的对象。主要用于创建一个复杂的对象，主要有两个作用：
     1. 隔离客户和产品对象的生产过程
     2. 负责控制产品对象的生产过程

1.创建一个指挥者，指挥者用于指挥建造产品的流程，流程对于某大类下的各种产品是一致的
2.创建一个建造者，该建造者建造的产品是某大类下特定的产品，比如房子中的别墅，汽车中的劳斯莱斯 
3.指挥者通过指挥建造者去建造特定的产品，所以只需要创建一个指挥者并调用其方法，而不需要知道具体的产品建造流程

代码实现：

/**
 * 产品，Product
 */
public class House {
    private String basic;
    private String wall;
    private String roofed;

    public String getBasic() {
        return basic;
    }
    public void setBasic(String basic) {
        this.basic = basic;
    }
    public String getWall() {
        return wall;
    }
    public void setWall(String wall) {
        this.wall = wall;
    }
    public String getRoofed() {
        return roofed;
    }
    public void setRoofed(String roofed) {
        this.roofed = roofed;
    }
}

/**
 * 抽象的建造者
 */
public abstract class HouseBuilder {
    //创建产品对象
    protected House house = new House();
    //建造流程的抽象方法
    public abstract void buildBasic();
    public abstract void buildWall();
    public abstract void buildRoof();
    //返回建造好的房子
    public House buildHouse(){
        return house;
    }
}

public class CommonHouse extends HouseBuilder{
    @Override
    public void buildBasic() {
        System.out.println("普通房子打地基");
        house.setBasic("普通房子的地基");
    }
    @Override
    public void buildWall() {
        System.out.println("普通房子砌墙");
        house.setWall("普通房子的墙");
    }
    @Override
    public void buildRoof() {
        System.out.println("普通房子盖房顶");
        house.setRoofed("普通房子的屋顶");
    }
}

/**
 * 指挥者，这里动态地指定建造流程，返回产品
 **/
public class HouseDirector {
    HouseBuilder houseBuilder = null;
    //方法1. 通过构造器传入建造者对象
    public HouseDirector(HouseBuilder houseBuilder){
        this.houseBuilder = houseBuilder;
    }
    //方法2. 通过setter传入建造者对象
    public void setHouseBuilder(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }
    //如何处理建造房子的流程，交给指挥者
    public House constructHouse(){
        houseBuilder.buildBasic();
        houseBuilder.buildWall();
        houseBuilder.buildRoof();
        return houseBuilder.buildHouse();
    }
}

public class Client {
    public static void main(String[] args) {
        //盖普通房子
        CommonHouse commonHouse = new CommonHouse();
        //准备建造房子的指挥者
        HouseDirector houseDirector = new HouseDirector(commonHouse);
        //完成盖房子，返回产品
        House house = houseDirector.constructHouse();
    }
}

建造者模式在当创建复杂对象时推荐使用，即如果一个对象有很多成员变量需要赋值，则推荐使用建造者模式

建造者模式变种：

参考：1. https://blog.csdn.net/bicheng4769/article/details/80988996
     2. https://www.jianshu.com/p/afe090b2e19c

public class Person {
    private int id;
    private final String name;  
    private final String gender; 
    private Date birth;
    private String job;
    private double height;
    private double weight;
    private String address;

    private Person(Builder builder) {
        this.name = builder.name;
        this.gender = builder.gender;
        this.birth = builder.birth;
        this.job = builder.job;
        this.height = builder.height;
        this.weight = builder.weight;
        this.address = builder.address;
    }

    public static class Builder{
        private final String name;
        private final String gender;
        private Date birth;
        private String job;
        private double height;
        private double weight;
        private String address;

        public Builder(String name,String gender) {
            this.name = name;
            this.gender = gender;
        }
        public Builder birth(Date birth){
            this.birth = birth;
            return this;
        }
        public Builder job(String job){
            this.job = job;
            return this;
        }
        public Builder height(double height){
            this.height = height;
            return this;
        }
        public Builder weight(double weight){
            this.weight = weight;
            return this;
        }
        public Builder address(String address){
            this.address = address;
            return this;
        }

        public Person build(){
            return new Person(this);
        }
    }
}

创建Person对象时：
 Person person = new Person.Builder("jarvis","male")
            .height(178).weight(61).job("程序员")
            .build();