//此总结为个人原创，有任何问题欢迎指出并改正，谢谢支持

简介

       作用：

      1.将一个复杂对象的构建过程与它的表示分离，从而使得相同的构建过程可以创建不同的表示；

      2.创建者模式隐藏了复杂对象的创建过程，它把复杂对象的构建加以抽象，通过子类继承或者重载的方式，动态的创建具有复合属性的对象。

应用场景

      动态创建复杂的对象

四个要素

①建造者（Builder）

    对复杂对象定义抽象接口；该接口规定了要实现复杂对象的各个部分的构建，不涉及具体对象的具体的构建。

②具体创建者（ConcreteBuilder）

   1.实现Builder接口，针对不同的业务逻辑，具体化复杂对象的各个部分的创建；

   2.在建造过程完成后，提供产品的实例

③指导者（Director）

    调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或者按某种顺序创建。

④产品（Product）

    要创建的复杂的对象，一般来说包含多个部分或属性。

实例

Product

public class Person {
    private String body;
    private String head;
    private String foot;

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }

    public String getHead() {
        return head;
    }

    public void setHead(String head) {
        this.head = head;
    }

    public String getFoot() {
        return foot;
    }

    public void setFoot(String foot) {
        this.foot = foot;
    }
}

Builder

public interface Builder {
    void builderHead(String head);
    void builderBody(String body);
    void builderFoot(String foot);
    Person builderPerson();
}

ConcreteBuilder 

public class ManBuilder implements Builder {
    private Person person = null;
    public ManBuilder() {
        person = new Person();
    }


    @Override
    public void builderHead(String head) {
        person.setHead(head);
    }

    @Override
    public void builderBody(String body) {
        person.setBody(body);
    }

    @Override
    public void builderFoot(String foot) {
        person.setFoot(foot);
    }

    @Override
    public Person builderPerson() {
        return person;
    }
}

Director

public class PersonDirector {
    public Person creatPerson(Builder manBuilder){
        manBuilder.builderFoot(\"foot\");
        manBuilder.builderBody(\"body\");
        manBuilder.builderHead(\"head\");
        return manBuilder.builderPerson();
    }
}

调用

PersonDirector pd = new PersonDirector();
Person person = pd.creatPerson(new ManBuilder());

实例2

public class NewMan {
    private String body;
    private String head;
    private String foot;

    public NewMan(String body, String head, String foot) {
        this.body = body;
        this.head = head;
        this.foot = foot;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }

    public String getHead() {
        return head;
    }

    public void setHead(String head) {
        this.head = head;
    }

    public String getFoot() {
        return foot;
    }

    public void setFoot(String foot) {
        this.foot = foot;
    }
    public static Builder getBuilder(){
        return new Builder();
    }
    public static class Builder{
        private String body;
        private String head;
        private String foot;
        public Builder builderHead(String h){
            head = h;
           return this;
        }
        public Builder builderBody(String b){
            body = b;
            return this;
        }
        public Builder builderFoot(String f){
            foot = f;
            return this;
        }
        public NewMan build(){
            return new NewMan(body,head,foot);
        }

    }
}

调用

NewMan newMan = NewMan.getBuilder().builderBody(\"body\").builderFoot(\"foot\").builderHead(\"head\").build();

建造者模式的优点

        首先，建造者模式的封装性很好。使用建造者模式可以有效的封装变化，在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此，将主要的业务逻辑封装在导演类中对整体而言可以取得比较好的稳定性。

        其次，建造者模式很容易进行扩展。如果有新的需求，通过实现一个新的建造者类就可以完成，基本上不用修改之前已经测试通过的代码，因此也就不会对原有功能引入风险