设计模式之建造者模式

3.3 建造者模式

建造者模式可以将复杂产品的构建与表示分离。适合相似产品的构造。

举一个例子：工人造房子，需要打地基等，这些工作由指导员指导工人的工作顺序

package builder;

//产品：需要组件ABCD
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 builder builderA();//地基
    abstract builder builderB();//砌砖
    abstract builder builderC();//刷墙
    abstract builder builderD();//拉线
    abstract product getProduct();//完成
}

//实际建造者：工人
public class worker extends builder{
    product product;
    public worker() {
        product = new product();
    }
    @Override
    builder builderA() {
        System.out.println("地基");
        return this;
    }

    @Override
    builder builderB() {
        System.out.println("砌砖");
        return this;
    }

    @Override
    builder builderC() {
        System.out.println("刷墙");
        return this;
    }

    @Override
    builder builderD() {
        System.out.println("拉线");
        return this;
    }

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

//只指挥者：指导工人工作的顺序
public class leader {
    public void lead(worker worker){
        worker.builderA();
        worker.builderB();
        worker.builderC();
        worker.builderD();
    }
}

public class test {
    public static void main(String[] args) {
        leader leader=new leader();
        leader.lead(new worker());
    }
}

分析：由指导者负责安排工人的工作的顺序，工人只需要负责工作，符合单一职责原则。将构建与表现分离，只要产品可以由ABCD中的组，就可以通过指导不同的生产。适用于生产有类似构造的产品。
案例2：套餐服务。平时我们在餐饮店吃饭，比如我们点一个菜，它都会有默认的配料和口味，用户也可以自己选择口味和配料。
//产品套餐：默认套装ABCD

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 builder builderA(String msg);
    abstract builder builderB(String msg);
    abstract builder builderC(String msg);
    abstract builder builderD(String msg);
    abstract product getProduct();
}

//实际建造者：服务员
public class worker extends builder {
    private product product;
    public worker() {
        product = new product();
    }
    @Override
    builder builderA(String msg) {
        product.setBuilderA(msg);
        return this;
    }

    @Override
    builder builderB(String msg) {
        product.setBuilderB(msg);
        return this;
    }

    @Override
    builder builderC(String msg) {
        product.setBuilderC(msg);
        return this;
    }

    @Override
    builder builderD(String msg) {
        product.setBuilderD(msg);
        return this;
    }

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

测试

public class test2 {
    public static void main(String[] args) {
        //按默认套装
        worker worker=new worker();
        System.out.println(worker.getProduct());
        //客户可更改套装
        worker.builderA("鸡翅")
                .builderD("雪碧");
        System.out.println(worker.getProduct());


    }
}

运行结果：

product{builderA='汉堡', builderB='可乐', builderC='薯条', builderD='炸鸡'}
product{builderA='鸡翅', builderB='可乐', builderC='薯条', builderD='雪碧'}

结果分析：用户只需要跟服务员说更换就可以，与上个案例相比没有指导者。用户也不必关心如何做，只要进行选择，然后服务员来做。