建造者模式

1.将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。如果用了建造者模式，那么用户就只需指定需要建造的类型就可以得到它们，而具体建造的过程和细节就不需要知道。

2.建造者模式结构图

3.角色
(1)、Builder：为创建一个产品对象的各个部件指定抽象接口。
(2)、ConcreteBuilder：实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，并提供一个检索产品的接口。
(3)、Director：构造一个使用Builder接口的对象，指导构建过程。
(4)、Product：表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

4.例子：构建男跟女
(1)产品（Product）角色
由一系列部件组成，一般是一个较为复杂的对象，也就是说创建对象的过程比较复杂，一般会有比较多的代码量。在本类图中，产品类是一个具体的类，而非抽象类。实际编程中，产品类可以是由一个抽象类与它的不同实现组成，也可以是由多个抽象类与他们的实现组成。

//表示被构建的复杂对象
public class Person {
    private String head;
    private String body;
    private String foot;

    public String getHead() {
        return head;
    }

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

    public String getBody() {
        return body;
    }

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

    public String getFoot() {
        return foot;
    }

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

public class Man extends Person{
    public Man(){  
        System.out.println("开始建造男人");  
   } 
}

public class Woman extends Person {
    public Woman() {
        System.out.println("开始建造女人");
    }
}

抽象建造者（Builder）角色
给出一个抽象接口，以规范产品对象的各个组成成分的建造。一般而言，此接口独立于应用程序的商业逻辑。模式中直接创建产品对象的是具体建造者 (ConcreteBuilder)角色。具体建造者类必须实现这个接口所要求的两种方法：一种是建造方法(buildPart)，另一种是返还结构方法(getResult)。一般来说，产品所包含的零件数目与建造方法的数目相符。换言之，有多少零件，就有多少相应的建造方法。
　　引入抽象建造者的目的，是为了将建造的具体过程交与它的子类来实现。这样更容易扩展。一般至少会有两个抽象方法，一个用来建造产品，一个是用来返回产品。

//Builder :为创建一个产品对象的各个部件指定抽象接口
public interface PersonBuilder {
    void buildHead();

    void buildBody();

    void buildFoot();

    Person buildPerson();
}

具体建造者（ConcreteBuilder）角色
实现抽象类的所有未实现的方法，具体来说一般是两项任务：组建产品；返回组建好的产品。

public class ManBuilder implements PersonBuilder {
    Person person;

    public ManBuilder() {
        person = new Man();
    }

    public void buildBody() {
        person.setBody("建造男人的身体");
    }

    public void buildFoot() {
        person.setFoot("建造男人的脚");
    }

    public void buildHead() {
        person.setHead("建造男人的头");
    }

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

}




public class WomanBuilder implements PersonBuilder {
    Person person;

    public WomanBuilder() {
        person = new Woman();
    }

    public void buildBody() {
        person.setBody("建造女人的身体");
    }

    public void buildFoot() {
        person.setFoot("建造女人的脚");
    }

    public void buildHead() {
        person.setHead("建造女人的头");
    }

    public Person buildPerson() {
        return person;
    }
}

导演者（Director）角色
负责调用适当的建造者来组建产品，导演类一般不与产品类发生依赖关系，与导演类直接交互的是建造者类。一般来说，导演类被用来封装程序中易变、及其复杂的部分。导演者角色并没有产品类的具体知识，真正拥有产品类的具体知识的是具体建造者角色。

　　导演者角色是与客户端打交道的角色。导演者将客户端创建产品的请求划分为对各个零件的建造请求，再将这些请求委派给具体建造者角色。具体建造者角色是做具体建造工作的，但是却不为客户端所知。

//Director：构造一个使用Builder接口的对象，指导构建过程。
public class PersonDirector {
    public Person constructPerson(PersonBuilder pb) {  
        pb.buildHead();  
        pb.buildBody();  
        pb.buildFoot();  
        return pb.buildPerson();  
   }  
}

public class Test {

    public static void main(String[] args) {
        PersonDirector pd = new PersonDirector();  
        Person womanPerson = pd.constructPerson(new ManBuilder());  
        Person manPerson = pd.constructPerson(new WomanBuilder()); 
    }

}

5.“遇到多个构造器参数时要考虑用构建器”，其实这里的构建器就属于建造者模式，只是里面把四个角色都放到具体产品里面了。

6.如果具体的被建造对象只有一个的话，可以省略抽象的Builder和Director，让ConcreteBuilder自己扮演指导者和建造者双重角色，甚至ConcreteBuilder也可以放到Product里面实现。

7.上面只制造男

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

     public String getHead() {  
          return head;  
     }  
     public void setHead(String head) {  
          this.head = head;  
     }  
     public String getBody() {  
          return body;  
     }  
     public void setBody(String body) {  
          this.body = body;  
     }  
     public String getFoot() {  
          return foot;  
     }  
     public void setFoot(String foot) {  
          this.foot = foot;  
     }  
} 

public class ManBuilder{  
     Man man;  
     public ManBuilder() {  
          man = new Man();  
     }  
     public void buildbody() {  
          man.setBody("建造男人的身体");  
     }  
     public void buildFoot() {  
          man.setFoot("建造男人的脚");  
     }  
     public void buildHead() {  
          man.setHead("建造男人的头");  
     }  
     public Man builderMan() {  
          buildHead();  
          buildBody();  
          buildFoot();  
          return man;  
     }  
}

public class Test{  
     public static void main(String[] args) {  
          ManBuilder builder = new ManBuilder();  
          Man man = builder.builderMan();  
     }  
} 

.建造者模式的好处就是使得建造代码与表示代码分离，由于建造者隐藏了该产品是如何组装的，所以若需要改变一个产品的内部表示，只需要再定义一个具体的建造者就可以。