1. 定义

将产品的内部结构（零件）与产品的生产过程分割开来，使一个建造过程可以按步骤构造出具有不同结构的产品。

• 对象：产品
• 对象的不同性质：产品的不同零件

2. 使用

• 部分构造
  • 抽象构造者：定义抽象方法，规范产品对象的各个组成零件的建造，提供产品
  • 具体构造者：实现抽象方法，提供具体的产品
  • 具体产品类：具体构造的成果
• 整体构造
  • 整体构建者：按照确定的步骤，根据不同的构造者构造产品
• 客户：使用具体构造者，通过整体构建者建造产品

（1）部分构造

package BuildPattern;

/**
 * 抽象建造者
 */
public abstract class Builder {

    //建造步骤
    public void buildA(int param){

    }
    public void buildB(int param){

    }

    //返回产品
    public Product getProduct(){
         return null;
    }
}

package BuildPattern;

/**
 * 具体构造产品A
 */
public class BulderA extends Builder {

    private Product a = new Product();

    @Override
    public void buildA(int param) {
        a.setA(param);
    }

    @Override
    public Product getProduct() {
        return a;
    }
}

package BuildPattern;

/**
 * 具体构造产品B
 */
public class BuilderB extends Builder {
    private Product b = new Product();

    @Override
    public void buildB(int param) {
        b.setB(param);
    }

    @Override
    public Product getProduct() {
        return b;
    }
}

package BuildPattern;

/**
 * 具体产品
 */
public class Product {

    int a = 0;

    int b = 0;

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }

    public int getB() {
        return b;
    }

    public void setB(int b) {
        this.b = b;
    }

    @Override
    public String toString() {
        return "Product{" +
                "a=" + a +
                ", b=" + b +
                '}';
    }
}

（2）整体构造

package Bui**加粗样式**ldPattern;

/**
 * 整体构建
 */
public class Director {

    private Builder builder;

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

    public void construct(int a,int b){
        builder.buildA(a);
        builder.buildB(b);
    }
}

（3）测试

package BuildPattern;

public class Test {
    public static void main(String[] args) {
        Builder builder = new BulderA();
        Director director = new Director(builder);
        director.construct(100,100);
        Product product = builder.getProduct();
        System.out.println(product);
    }
}

3. 特点

• 封装对象的创建过程
• 隐藏产品内部的结构：每一个内部成分本身可以是对象，也可以仅仅是产品对象的一个组成部分
• 允许多个步骤创建对象：避免对象的属性相互依赖