1.建造者模式：是将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
1、Builder：给出一个抽象接口，以规范产品对象的各个组成成分的建造。这个接口规定要实现复杂对象的哪些部分的创建，并不涉及具体的对象部件的创建。
2、ConcreteBuilder：实现Builder接口，针对不同的商业逻辑，具体化复杂对象的各部分的创建。 在建造过程完成后，提供产品的实例。
3、Director：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。
4、Product：要创建的复杂对象。
example：
二、实例演示
这里以游戏开发中人物的构造过程为例。在游戏中创建一个形象时，需要对每个部位进行创建。简化而言，需要创建头部，身体和四肢。
1、Product（要创建的复杂对象）：
建立一个人物对象Person
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;
}
}
2、Builder（给出一个抽象接口，以规范产品对象的各个组成成分的建造。这个接口规定要实现复杂对象的哪些部分的创建，并不涉及具体的对象部件的创建）：
public interface PersonBuilder {
void buildHead();
void buildBody();
void buildFoot();
Person buildPerson();//组装
}
3、ConcreteBuilder（实现Builder接口，针对不同的商业逻辑，具体化复杂对象的各部分的创建。 在建造过程完成后，提供产品的实例）：
public class ManBuilder implements PersonBuilder {
Person person;
public ManBuilder() {
person = new Person();//创建一个person实例，用于调用set方法
}
public void buildBody() {
person.setBody("建造身体部分");
}
public void buildFoot() {
person.setFoot("建造四肢部分");
}
public void buildHead() {
person.setHead("建造头部部分");
}
public Person buildPerson() {
return person;//返回一个person实例
}
}
4、Director（调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建）：
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 person = pd.constructPerson(new ManBuilder());
System.out.println(person.getBody());
System.out.println(person.getFoot());
System.out.println(person.getHead());
}
}
2. 建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。
建造者模式主要包含四个角色
Product（产品角色）：一个具体的产品对象。
Builder（抽象建造者）：创建一个Product对象的各个部件指定的抽象接口。
ConcreteBuilder（具体建造者）：实现抽象接口，构建和装配各个部件。
Director（指挥者）：构建一个使用Builder接口的对象。它主要是用于创建一个复杂的对象。它主要有两个作用，一是：隔离了客户与对象的生产过程，二是：负责控制产品对象的生产过程。
1 ) 一个典型的复杂对象其类代码示例如下：
public class Product
{
private String partA; //可以是任意类型
private String partB;
private String partC;
//partA的Getter方法和Setter方法省略
//partB的Getter方法和Setter方法省略
//partC的Getter方法和Setter方法省略
}
2 ) 抽象建造者类中定义了产品的创建方法和返回方法，其典型代码如下：
public abstract class Builder
{
protected Product product=new Product();
public abstract void buildPartA();
public abstract void buildPartB();
public abstract void buildPartC();
public Product getResult()
{
return product;
}
}
3 ) 具体建造者。实现抽象接口，构建和装配各个部件,实例代码如下：
public class ConcreteBuilder extends Builder{
public void buildPartA(){
...
}
public void buildPartB(){
...
}
public void buildPartC(){
...
}
}
4）指挥者类的代码示例如下：
建造者模式的结构中还引入了一个指挥者类Director，该类的作用主要有两个：一方面它隔离了客户与生产过程；另一方面它负责控制产品的生成过程。指挥者针对抽象建造者编程，客户端只需要知道具体建造者的类型，即可通过指挥者类调用建造者的相关方法，返回一个完整的产品对象。
public class Director
{
private Builder builder;
//1 构造方法的方式注入builder对象
public Director(Builder builder)
{
this.builder=builder;
}
//2 set方法注入builder对象
public void setBuilder(Builder builder)
{
this.builder=builer;
}
public Product construct()
{
builder.buildPartA();
builder.buildPartB();
builder.buildPartC();
return builder.getResult();
}
}
5 ) 客户端类代码片段：
Builder builder = new ConcreteBuilder();
Director director = new Director(builder);
Product product = director.construct();
1、建造者模式是将一个复杂对象的创建过程给封装起来，客户只需要知道可以利用对象名或者类型就能够得到一个完整的对象实例，而不需要关心对象的具体创建过程。
2、建造者模式将对象的创建过程与对象本身隔离开了，使得细节依赖于抽象，符合依赖倒置原则。可以使用相同的创建过程来创建不同的产品对象。