建造者模式(Builder Pattern)：将一个复杂对象（产品）的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。也被称为生成器模式。
建造者模式是复杂对象的组装和创建，是一种对象创建型模式，满足依赖倒转原则（细节依赖于抽象，而非抽象依赖于细节）。

假设一个复杂的对象可以看做是一个产品的话，那么该对象的方法（或称内部表象）就对应了产品的零件，通过建造者模式，客户不需要知道建造的具体细节，只需要指定需要建造的类型就可以得到对应的产品。
建造者模式主要包含四个角色：

• 抽象建造者Builder：声明创建一个产品的各个部件指定的抽象接口。
• 具体建造者ConcreteBuilder：实现抽象接口，创建和组装各个部件。
• 指挥者Director：又称导演类，负责处理复杂对象的组装顺序，隔离了客户与产品的生产过程，客户端只需要与指挥者进行交互。
• 产品类Product：一个具体的产品。

UML关系图如下：

代码如下：

1. Builder.java

/**
 * 抽象建造者
 * @author sywyg
 * @since 2015.8.27
 *
 */
public interface Builder {
    void BuildProduct();
    void addPartA(String name);
    void addPartB(String name);
    void addPartC(String name);
    Product getResult();
}

1. ConcreteBuilder.java

/**
 * 具体建造者
 * @author sywyg
 * @since 2015.8.27
 *
 */
public class ConcreteBuilder implements Builder {
    private Product product;
    @Override
    public void BuildProduct() {
        product = new Product();
    }
    @Override
    public void addPartA(String name) {
        A a = new A(name);
        product.setA(a);
        System.out.println("添加部件A成功");
    }
    @Override
    public void addPartB(String name) {
        B b = new B(name);
        product.setB(b);
        System.out.println("添加部件B成功");
    }
    @Override
    public void addPartC(String name) {
        C c = new C(name);
        product.setC(c);
        System.out.println("添加部件C成功");
    }
    @Override
    public Product getResult() {
        return product;
    }

}

1. Director.java

/**
 * 指挥者，指挥产品的生产过程
 * @author sywyg
 * @since 2015.8.27
 *
 */
public class Director {

    private Builder builder;
    public Director(Builder builder){
        this.builder = builder;
    }
    public Product construct(){
        builder.BuildProduct();
        builder.addPartA("部件A");
        builder.addPartC("部件C");
        builder.addPartB("部件B");
        return builder.getResult();
    }

}

1. Product.java

/**
 * 产品类：由三个部件够成
 * @author sywyg
 * @since 2015.8.27
 *
 */
public class Product {
    private A a;
    private B b;
    private C c;
    public A getA() {
        return a;
    }
    public void setA(A a) {
        this.a = a;
    }
    public B getB() {
        return b;
    }
    public void setB(B b) {
        this.b = b;
    }
    public C getC() {
        return c;
    }
    public void setC(C c) {
        this.c = c;
    }
}
class A{
    private String name;
    public A(String name){
        this.name = name;
    }
}
class B{
    private String name;
    public B(String name){
        this.name = name;
    }
}
class C{
    private String name;
    public C(String name){
        this.name = name;
    }
}

对上面进行测试，代码如下：

public class Client {
    public static void main(String[] args) {
        // 首先创建具体建造者
        Builder builder = new ConcreteBuilder();
        // 根据具体建造者创建导演类
        Director director = new Director(builder);
        // 直接调用导演类的建造方法创建产品
        Product product = director.construct();
    }

}

建造者优点

• 将一个复杂对象的建造过程封装起来，细节依赖于抽象。
• 允许对象通过多个步骤来创建，并且可以改变工程。
• 向客户隐藏产品内部的表现。
• 产品的实现可以被替换（增加具体建造者），因为客户只看到一个抽象的接口。

缺点

• 与工厂模式相比，采用建造者模式创建对象的客户，需要具备更多的领域知识。
• 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，其使用范围受到一定的限制。
• 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。

用途

• 经常被用来创建组合结构。
• 需要生成的产品对象的属性相互依赖，需要指定其生成顺序。