建造者模式(Builder Pattern）

1.建造者模式：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
2.类型 ：对象创建型模式
3.
4.各部分说明
**产品类：**一般是一个较为复杂的对象，也就是说创建对象的过程比较复杂，一般会有比较多的代码量。在本类图中，产品类是一个具体的类，而非抽象类。实际编程中，产品类可以是由一个抽象类与它的不同实现组成，也可以是由多个抽象类与他们的实现组成。
**抽象建造者：**引入抽象建造者的目的，是为了将建造的具体过程交与它的子类来实现。这样更容易扩展。一般至少会有两个抽象方法，一个用来建造产品，一个是用来返回产品。
**建造者：**实现抽象类的所有未实现的方法，具体来说一般是两项任务：组建产品；返回组建好的产品。
**导演类：**负责调用适当的建造者来组建产品，导演类一般不与产品类发生依赖关系，与导演类直接交互的是建造者类。一般来说，导演类被用来封装程序中易变的部分。
5.实现

package 建造者模式;

public class BuilderPattern {
    public static void main(String[] args) {
        ConcreteBuilder concreteBuilder = new ConcreteBuilder();
        Director director = new Director(concreteBuilder);
        Product product = director.construct();
        System.out.println(product.toString());
        System.out.println("-----------------");
        ConcreteBuilder2 concreteBuilder2 = new ConcreteBuilder2();
        director = new Director(concreteBuilder2);
        product = director.construct();
        System.out.println(product);
    }

}

//产品类
class Product{
    private String partA;
    private String partB;
    private String partC;

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

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

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

    public String getPartA() {
        return partA;
    }

    public String getPartB() {
        return partB;
    }

    public String getPartC() {
        return partC;
    }

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

//抽象建造者
interface Builder{
    public  void buildPartA();
    public  void buildPartB();
    public  void buildPartC();
    public  Product getResult();
}
//具体建造者
class ConcreteBuilder implements Builder{
    Product product = new Product();

    @Override
    public void buildPartA() {
        product.setPartA("A");
    }

    @Override
    public void buildPartB() {
        product.setPartB("B");
    }

    @Override
    public void buildPartC() {
        product.setPartC("C");
    }

    @Override
    public Product getResult() {
        return product;
    }
}
//具体建造者
class ConcreteBuilder2 implements Builder{
    Product product = new Product();

    @Override
    public void buildPartA() {
        product.setPartA("aa");
    }

    @Override
    public void buildPartB() {
        product.setPartB("bb");
    }

    @Override
    public void buildPartC() {
        product.setPartC("cc");
    }

    @Override
    public Product getResult() {
        return product;
    }
}
//指挥/导演类
class Director {
    private Builder builder;

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

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

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

6.优点
建造者模式的封装性很好。使用建造者模式可以有效的封装变化，在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此，将主要的业务逻辑封装在导演类中对整体而言可以取得比较好的稳定性。
建造者模式很容易进行扩展。如果有新的需求，通过实现一个新的建造者类就可以完成，基本上不用修改之前已经测试通过的代码，因此也就不会对原有功能引入风险。
7.缺点
使用范围有限。如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。