建造者模式以及在 StringBuilder 中的应用

前文

设计模式的七大原则

单例模式

编写一个接口，实现代理设计模式（Proxy）

工厂模式

迭代器模式

原型设计模式以及在 Spring 中的使用

适配器模式以及在 SpringMVC 中的应用

设计模式 —— 桥接模式

装饰者设计模式

建造者模式

基本介绍

• 建造者模式又叫生成器模式，是一种对象构建模式。它可以将复杂对象的建造过程抽象出来（抽象类别），使这个抽象过程的不同实现方法可以构造出不同的表现（属性）的对象
• 建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节

建造者模式的四个角色

• Product （产品角色）：一个具体的产品对象
• Builder（抽象建造者）：创建一个 Product 对象的各个部件指定的接口 / 抽象类
• ConcreteBuilder （具体建造者）：实现接口，构建和装配各个部件
• Director（指挥者）：构建一个使用 Builder 接口的对象。它主要是用于创建一个复杂的对象。它主要有两个作用，一个是：隔离了客户与对象的生产过程，二是：负责控制产品对象的生产过程

代码实现

首先定义一个 Product 类（产品）

package com.java.springtest.improve;

// 产品 ——》 Product
public class House {

    private String base;
    private String wall;
    private String roofed;

    public String getBase() {
        return base;
    }

    public void setBase(String base) {
        this.base = base;
    }

    public String getWall() {
        return wall;
    }

    public void setWall(String wall) {
        this.wall = wall;
    }

    public String getRoofed() {
        return roofed;
    }

    public void setRoofed(String roofed) {
        this.roofed = roofed;
    }

    @Override
    public String toString() {
        return "House{" +
                "base='" + base + '\'' +
                ", wall='" + wall + '\'' +
                ", roofed='" + roofed + '\'' +
                '}';
    }
}

然后定义一个建造者

package com.java.springtest.improve;

// 抽象的建造者
public abstract class HouseBuilder {

    protected House house = new House();

    // 将建造的流程写好，抽象方法
    public abstract void buildBase();
    public abstract void buildWall();
    public abstract void roofed();

    // 建造房子,然后将产品（房子）return
    public House buildHouse() {
        return house;
    }
}

普通房子的建造流程

package com.java.springtest.improve;

public class CommonHouse extends HouseBuilder {
    @Override
    public void buildBase() {
        System.out.println("普通房子打地基");
    }

    @Override
    public void buildWall() {
        System.out.println("普通房子砌墙");
    }

    @Override
    public void roofed() {
        System.out.println("普通房子的屋顶");
    }
}

高楼的建造者

package com.java.springtest.improve;

/**
 * @author Woo_home
 * @create by 2020/2/17
 */
public class HighBuilder extends HouseBuilder {
    @Override
    public void buildBase() {
        System.out.println("高楼打地基");
    }

    @Override
    public void buildWall() {
        System.out.println("高楼砌墙");
    }

    @Override
    public void roofed() {
        System.out.println("高楼的透明屋顶");
    }
}

指挥者

package com.java.springtest.improve;

// 指挥者，这里动态地去指定制作流程，返回产品
public class HouseDirector {

    HouseBuilder houseBuilder = null;

    // 构造器传入 houseBuilder
    public HouseDirector(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    // 通过 setter 传入 houseBuilder
    public void setHouseBuilder(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }`在这里插入代码片`

    // 如何处理建造房子的流程，交给指挥者
    public House constructHouse() {
        houseBuilder.buildBase();
        houseBuilder.buildWall();
        houseBuilder.roofed();
        return houseBuilder.buildHouse();
    }
}

客户端实现

package com.java.springtest.improve;

public class Client {
    public static void main(String[] args) {
        // 盖普通房子
        CommonHouse commonHouse = new CommonHouse();
        // 准备创建房子的指挥者
        HouseDirector houseDirector = new HouseDirector(commonHouse);
        // 完成盖房子，返回产品
        houseDirector.constructHouse();

        System.out.println("--------------------------------------------");

        // 盖高楼
        HighBuilder highBuilder = new HighBuilder();

        // 重置建造者
        houseDirector.setHouseBuilder(highBuilder);

        // 完成盖房子，返回产品
        houseDirector.constructHouse();
    }
}

建造者模式在 StringBuilder 中的应用

在介绍之前先看下下面这段代码，走你

package com.java.springtest.improve;

public class BuilderTest {
    public static void main(String[] args) {
        StringBuilder builder = new StringBuilder("Hello World");
        System.out.println(builder);
    }
}

输出：

这段代码很简单哈（好像说了等于没说），别急，一步一步来。我们点开 StringBuilder 的源码

发现 StringBuilder 继承了一个 AbstractStringBuilder 类，我们点开 AbstractStringBuilder 类看下，发现 AbstractStringBuilder 实现了一个 Appendable 接口

建造者模式在 StringBuilder 中的源码分析

• Appendable 接口定义了多个 append 方法（抽象方法），即 Appendable 为抽象建造者，定义了抽象方法
• AbstractStringBuilder 实现了 Appendable 接口方法，这里的 AbstractStringBuilder 已经是就建造者，只是不能实例化
• StringBuilder 即充当了指挥者角色，同时也充当了具体的建造者，建造方法的实现是由 AbstractStringBuilder 完成，而 StringBuilder 继承了 AbstractStringBuilder