定义

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

角色

Builder（抽象建造者）

为产品对象的各个部件指定抽象接口。通常包含两类方法：（1）buildPartX(),用于创建复杂对象的各个部位（2）getResult()，用于返回复杂对象。

public abstract class Builder {
    protected Product product =new Product();

    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract void buildPartC();

    public Product gerResult(){
        return product;
    }
}

ConcreteBulider（具体建造者）

实现Builder接口

public class ConcreteBuilder extends Builder {
    @Override
    public void buildPartA() {
        System.out.println("组装A部分");
        product.setPartA("A部分");
    }

    @Override
    public void buildPartB() {
        System.out.println("组装B部分");
        product.setPartB("B部分");
    }

    @Override
    public void buildPartC() {
        System.out.println("组装C部分");
        product.setPartC("C部分");
    }
}

Product（产品）

被构建的复杂对象.

public class Product {
    private String partA;
    private String partB;
    private String partC;

    public String getPartA() {
        return partA;
    }

    public void setPartA(String partA) {
        this.partA = partA;
    }

    public String getPartB() {
        return partB;
    }

    public void setPartB(String partB) {
        this.partB = partB;
    }

    public String getPartC() {
        return partC;
    }

    public void setPartC(String partC) {
        this.partC = partC;
    }

    @Override
    public String toString() {
        return "Product{" +
                "partA='" + partA + '\'' +
                ", partB='" + partB + '\'' +
                ", partC='" + partC + '\'' +
                '}';
    }
}

Director（指挥者）

负责安排复杂对象的建造次序。

public class Director {
    private Builder builder;

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

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

    public Product construct(){
        builder.buildPartC();
        builder.buildPartB();
        builder.buildPartA();
        return builder.gerResult();
    }
}

客户类

public class BuilderClient {
    public static void main(String[] args) {
        Builder builder = new ConcreteBuilder();
        Director director = new Director(builder);
        Product product = director.construct();
        System.out.println(product.toString());
    }
}

测试结果：

组装C部分
组装B部分
组装A部分
Product{partA='A部分', partB='B部分', partC='C部分'}

优点

（1）将产品与创建过程解耦，使得相同的创建过程可以创建不同的产品对象。

（2）每一个具体建造者（产品的配置）相互独立。

（3）创建过程清晰可控

缺点

（1）不适用创建过程相差较大的产品之间

（2）对于内部变化复杂的产品，会增加系统的理解程度以及运行成本。

适用场景

（1）产品内部结构相对复杂

（2）产品创建过程存在先后次序

（3）需要对产品的创建和使用进行隔离