设计模式之构造者模式

类图：

Builder	接口或抽象类	抽象的建造者，不是必须的
Woker	具体的建造者	可以有多个「因为每个建造风格可能不一样」
Product	普通的类	具体的产品「即被建造的对象」
Director	导演也叫指挥者	统一指挥建造者去建造目标，导演不是必须的

具体产品：

public class Product {
    private String builderA;//地基
    private String builderB;//钢筋水泥
    private String builderC;//铺垫线
    private String builderD; //粉刷

    public String getBuilderA() {
        return builderA;
    }

    public String getBuilderB() {
        return builderB;
    }

    public String getBuilderC() {
        return builderC;
    }

    public String getBuilderD() {
        return builderD;
    }

    public void setBuilderA(String builderA) {
        this.builderA = builderA;
    }

    public void setBuilderB(String builderB) {
        this.builderB = builderB;
    }

    public void setBuilderC(String builderC) {
        this.builderC = builderC;
    }

    public void setBuilderD(String builderD) {
        this.builderD = builderD;
    }

    @Override
    public String toString() {
        return "Product{" +
                "builderA=" + builderA +
                ", builderB=" + builderB +
                ", builderC=" + builderC +
                ", builderD=" + builderD +
                '}';
    }
}

//抽象的建造者

public abstract class Builder {
    abstract void builderA();
    abstract void builderB();
    abstract void builderC();
    abstract void builderD(); 

    //完工，得到产品
    abstract Product getProduct();
}

//具体的建造者

public class Worker extends Builder{

    private Product product;

    public  Worker(){
        product = new Product();
    }
    @Override
    void builderA() {
        product.setBuilderA("地基");
        System.out.println("地基");
    }

    @Override
    void builderB() {
        product.setBuilderB("钢筋水泥");
        System.out.println("钢筋水泥");
    }

    @Override
    void builderC() {
        product.setBuilderC("铺电线");
        System.out.println("铺电线");
    }

    @Override
    void builderD() {
        product.setBuilderD("粉刷");
        System.out.println("粉刷");
    }

    @Override
    Product getProduct() {
        return product;
    }
}

//导演

public class Directory {
    public Product build(Builder builder){
        builder.builderA();
        builder.builderB();
        builder.builderC();
        builder.builderD();
        return builder.getProduct();
    }
}

//测试类

public class Test {
    public static void main(String[] args) {
        Directory directory = new Directory();
        Product product = directory.build(new Worker());
        System.out.println(product.toString());
    }
}

总结：

• 1、用户不知道对象的建造过程和细节就可以创建出复杂的对象「屏蔽了建造的具体细节」
• 2、用户只需给出复杂对象的内容和类型可以创建出对象
• 3、建造者模工按流程一步步的创建出复杂对象