建造者模式

定义：将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。
（separate the construction of a complex object from its representation so that the same construction process can create different representations）

这样的定义有点不知所云。直白点说，建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。
建造者模式主要是为了解决主要解决在软件系统中，有时候面临着”一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。这样的情况下，我们就可以使用建造者模式。

建造者模式UML类图（来自百度图片）：

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

下面是建造者模式Java示例代码：
Builder

public interface Builder {
    public void buildPartA();
    public void buildPartB();
    public void buildPartC();
    public Product getProduct();
}

ConcreteBuilder

public class ConcreteBuilder implements Builder {
    private Product product;

    @Override
    public void buildPartA() {
        PartA partA = new PartA();
        product.setPartA(partA);
    }

    @Override
    public void buildPartB() {
        PartB partB = new PartB();
        product.setPartB(partB);
    }

    @Override
    public void buildPartC() {
        PartC partC = new PartC();
        product.setPartC(partC);
    }

    @Override
    public Product getProduct() {
        return this.product;
    }   

}

Director

public class Director {
    private Builder builder;

    public Director(Builder builder) {
        this.builder = builder;
    }

    public void setBuilder(Builder builder) {
        this.builder = builder;
    }

    public void construct() {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
    }
}

Product

public class Product {
    private PartA partA;
    private PartB partB;
    private PartC partC;
    public PartA getPartA() {
        return partA;
    }
    public void setPartA(PartA partA) {
        this.partA = partA;
    }
    public PartB getPartB() {
        return partB;
    }
    public void setPartB(PartB partB) {
        this.partB = partB;
    }
    public PartC getPartC() {
        return partC;
    }
    public void setPartC(PartC partC) {
        this.partC = partC;
    }
}

客户端调用

public class Client {
    public static void main(String[] args) {
        Builder builder = new ConcreteBuilder();
        Director director = new Director(builder);
        director.construct();
        Product product = builder.getProduct();
    }
}

建造者模式的好处是：当我们构造每个子部件的算法有改变的时候，我们客户端的调用代码不需要发生改变。
为什么要有一个Director类呢？为什么不直接在Builder类中进行产品的组装。因为有可能不同的组装顺序会有不同的产品产出，我们分离出产品的组装，正好是分离出变化的部分，符合设计模式的基本原则。

建造者的使用场合：
1. 创建一些复杂的对象时，这些对象的内部组成构件间的建造顺序是稳定的，但是对象的内部组成构件面临着复杂的变化。
2. 创建一些复杂的对象时，这些对象内部组成构件见中的建造顺序不同产生了不同的效能，这个时候使用建造者模式是非常合适。

最后，Java中的StringBuilder也是建造者模式的使用，但是只能相当于一个ConcreteBuilder没有Director。