【设计模式学习】11种高频设计模式之建造者模式

---

相关介绍

1、定义

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

2、 作用

在用户不知道对象得建造过程和细节的情况下就可以直接创建复杂的对象。

3、理解

用户只需要给出指定复杂对象的类型和内容，建造者模式负责按顺序创建复杂的对象（把内部的建造过程和细节隐藏起来）。角色分析如下：

4、用法

• 常规用法

导演类Director在Builder模式种具有很重要的作用，它用于指挥具体构建者如何构建产品，控制调用先后次序，并向调用者返回完整的产品类，但是有些情况下需要简化系统结构，可以把Director和抽象建造者进行结合。
在实际情况中，服务员（具体建造者）可以随意搭配几种产品（零件）组成一款套餐（产品），然后出售给客户。

• 静态内部类方式

该方式实现零件无序装配构造，这种方式使用更加灵活，更符合定义。内部有复杂对象的默认实现，使用时可以根据用户需求自由定义更改内容，并且无需改变具体的构造方式，就可以生产出不同复杂产品。
在实际情况中，把指挥者交给用户操作，使得产品的创建更加灵活简单（可以选择改变套餐中的搭配）。

5、 优点

• 产品的建造和表示分离，实现了解耦。使用建造者模式可以是客户端不必知道产品内部组成的细节。
• 将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰。
• 具体的建造者类之间是相互独立的，这有利于系统的扩展。增加新的具体建造者无需修改原有类库的代码，符合“开闭原则”。

6、 缺点

• 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似；如果产品之间的差异性很大，则不适合使用建造者模式，因此其适用范围受到一定的限制。
• 如果产品的 内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大

7、 例子

• 工厂（建造者模式）：负责制造汽车（组装过程和细节再在工厂内）
• 汽车购买者（用户）：你只需要说出你需要的型号（对象的类型和内容），然后直接购买就可以使用了（不需要知道汽车是怎么组装的（车轮、车门、发动机、方向盘等））

代码介绍

常规用法

代码目录如下：

Builder类

package builder.general;

//抽象的建造者：方法
public abstract class Builder {
    abstract void buildA();     //地基
    abstract void buildB();     //钢筋工程
    abstract void buildC();     //铺电线
    abstract void buildD();     //粉刷

    abstract Product getProduct();
}

Product类

package builder.general;

//产品：房子
public class Product {
    private String buildA;
    private String buildB;
    private String buildC;
    private String buildD;

    public String getBuildA() {
        return buildA;
    }

    public void setBuildA(String buildA) {
        this.buildA = buildA;
    }

    public String getBuildB() {
        return buildB;
    }

    public void setBuildB(String buildB) {
        this.buildB = buildB;
    }

    public String getBuildC() {
        return buildC;
    }

    public void setBuildC(String buildC) {
        this.buildC = buildC;
    }

    public String getBuildD() {
        return buildD;
    }

    public void setBuildD(String buildD) {
        this.buildD = buildD;
    }

    @Override
    public String toString() {
        return "Product{" +
                "buildA=" + buildA +
                ", buildB=" + buildB +
                ", buildC=" + buildC +
                ", buildD=" + buildD +
                '}';
    }
}

Worker类

package builder.general;

//具体的建造者：工人
public class Worker extends Builder{
    private Product product;

    //注意这里！！！工人负责创建产品对象
    public Worker(){
        product=new Product();
    }

    @Override
    void buildA() {
        product.setBuildA("地基");
        System.out.println("地基");
    }

    @Override
    void buildB() {
        product.setBuildB("钢筋工程");
        System.out.println("钢筋工程");
    }

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

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

    @Override
    Product getProduct(){
        return product;
    }

Director类

package builder.general;

//指挥：核心。负责只会构建一个工程，工程如何构建。由它决定
public class Director {
    //指挥工人按照顺序完成任务
    public Product build(Builder builder){
        builder.buildA();
        builder.buildB();
        builder.buildC();
        builder.buildD();

        return builder.getProduct();
    }
}

Test类

package builder.general;

public class Test {
    public static void main(String[]args){
        //指挥
        Director director=new Director();
        //指挥具体的工人完成产品
        Product build=director.build(new Worker());
        System.out.println(build.toString());
    }
}

静态内部类方法

代码目录如下：

Builder类

package builder.staticInner;

//抽象的建造者：方法
public abstract class Builder {
    abstract Builder buildA(String msg);     //汉堡
    abstract Builder buildB(String msg);     //薯条
    abstract Builder buildC(String msg);     //可乐
    abstract Builder buildD(String msg);     //甜点

    abstract Product getProduct();
}

Product类

package builder.staticInner;

//产品：套餐
public class Product {
    private String buildA="汉堡";
    private String buildB="可乐";
    private String buildC="薯条";
    private String buildD="甜点";

    public String getBuildA() {
        return buildA;
    }

    public void setBuildA(String buildA) {
        this.buildA = buildA;
    }

    public String getBuildB() {
        return buildB;
    }

    public void setBuildB(String buildB) {
        this.buildB = buildB;
    }

    public String getBuildC() {
        return buildC;
    }

    public void setBuildC(String buildC) {
        this.buildC = buildC;
    }

    public String getBuildD() {
        return buildD;
    }

    public void setBuildD(String buildD) {
        this.buildD = buildD;
    }

    @Override
    public String toString() {
        return "Product{" +
                "buildA=" + buildA +
                ", buildB=" + buildB +
                ", buildC=" + buildC +
                ", buildD=" + buildD +
                '}';
    }
}

Worker类

package builder.staticInner;

//具体的建造者：服务员
public class Worker extends Builder {
    private Product product;

    //服务员负责创建产品对象
    public Worker(){
        product=new Product();
    }

    @Override
    Builder buildA(String msg) {
        product.setBuildA(msg);
        return this;        //this指当前调用buildA的worker，可以实现链式构建
    }

    @Override
    Builder buildB(String msg) {
        product.setBuildB(msg);
        return this;
    }

    @Override
    Builder buildC(String msg) {
        product.setBuildC(msg);
        return this;
    }

    @Override
    Builder buildD(String msg) {
        product.setBuildD(msg);
        return this;
    }

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

Test类

package builder.staticInner;

public class Test {
    public static void main(String[] args){
        //服务员
        Worker worker=new Worker();
        //链式编程：在原来的基础上，可以自由组合，如果不组合也有默认的套餐
        Product product=worker.buildC("辣条").buildA("奶茶").getProduct();

        System.out.println(product.toString());
    }
}

---

系列文章目录

一、单例模式
二、工厂模式
三、建造者模式
四、原型模式
五、适配器模式
六、代理模式
七、装饰器模式
八、迭代器模式
九、模板方法模式
十、策略模式
十一、责任链模式
十二、观察者模式
总结、12种常用设计模式

---

参考资料

【狂神说Java】单例模式-23种设计模式系列