模板方法模式的代码最终的效果就是将一系列组件（属性及方法）封装起来，至于如何组织、调用这些组件，以实现不同的需求，一方面直接交由 Client 来实现，不过更好的方式是使用使用建造者模式封装起来后，再由 Client 调用。

建造者模式的通用类图如下：

以下是标准的模板方法模式代码，通过 setSequence 传入不同的操作序列，可以定义不同的模板方法的调用顺序：

abstract class CarModel {
    // 这个参数是各个基本方法执行的顺序
    private ArrayList<String> sequence = new ArrayList<String>();

    // 模型是启动开始跑了
    protected abstract void start();

    // 能发动，还要能停下来，那才是真本事
    protected abstract void stop();

    // 喇叭会出声音，是滴滴叫，还是哔哔叫
    protected abstract void alarm();

    // 引擎会轰隆隆地响，不响那是假的
    protected abstract void engineBoom();

    // 那模型应该会跑吧，别管是人推的，还是电力驱动，总之要会跑
    final public void run() {
        // 循环一遍，谁在前，就先执行谁
        for (int i = 0; i < this.sequence.size(); i++) {
            String actionName = this.sequence.get(i);
            if (actionName.equalsIgnoreCase("start")) {
                this.start(); // 启动汽车
            } else if (actionName.equalsIgnoreCase("stop")) {
                this.stop(); // 停止汽车
            } else if (actionName.equalsIgnoreCase("alarm")) {
                this.alarm(); // 喇叭开始叫了
            } else if (actionName.equalsIgnoreCase("engine boom")) {
                // 如果是 engine boom 关键
                this.engineBoom(); // 引擎开始轰鸣
            }
        }
    }

    // 把传递过来的值传递到类内
    final public void setSequence(ArrayList<String> sequence) {
        this.sequence = sequence;
    }
}


class BenzModel extends CarModel {
    protected void alarm() {
        System.out.println("奔驰车的喇叭声音是这个样子的...");
    }

    protected void engineBoom() {
        System.out.println("奔驰车的引擎是这个声音的...");
    }

    protected void start() {
        System.out.println("奔驰车跑起来是这个样子的...");
    }

    protected void stop() {
        System.out.println("奔驰车应该这样停车...");
    }
}

class BMWModel extends CarModel {
    protected void alarm() {
        System.out.println("宝马车的喇叭声音是这个样子的...");
    }

    protected void engineBoom() {
        System.out.println("宝马车的引擎是这个声音的...");
    }

    protected void start() {
        System.out.println("宝马车跑起来是这个样子的...");
    }

    protected void stop() {
        System.out.println("宝马车应该这样停车...");
    }
}

Builder 类规范并导出 Product 的构建接口，具体如何构建一般是由子类实现：

abstract class CarBuilder {
    // 建造一个模型，你要给我一个顺序要求，就是组装顺序
    public abstract void setSequence(ArrayList<String> sequence);

    // 设置完毕顺序后，就可以直接拿到这个车辆模型
    public abstract CarModel getCarModel();
}

class BenzBuilder extends CarBuilder {
    private BenzModel benz = new BenzModel();

    public CarModel getCarModel() {
        return this.benz;
    }

    public void setSequence(ArrayList<String> sequence) {
        this.benz.setSequence(sequence);
    }
}

class BMWBuilder extends CarBuilder {
    private BMWModel bmw = new BMWModel();

    public CarModel getCarModel() {
        return this.bmw;
    }

    public void setSequence(ArrayList<String> sequence) {
        this.bmw.setSequence(sequence);
    }
}

Builder 类调用效果如下：

import java.util.ArrayList;

public class App {
    public static void main(String[] args) {

        // 存放 run 的顺序
        ArrayList<String> sequence = new ArrayList<String>();
        sequence.add("engine boom"); // 客户要求，run 的时候先发动引擎
        sequence.add("start"); // 启动起来
        sequence.add("stop"); // 开了一段就停下来
        // 要一个奔驰车：
        BenzBuilder benzBuilder = new BenzBuilder();
        benzBuilder.setSequence(sequence);
        /*
         * 客户告诉 XX 公司，我要这样一个模型，然后 XX 公司就告诉我老大
         * 说要这样一个模型，这样一个顺序，然后我就来制造
         */
        BenzModel benz = (BenzModel) benzBuilder.getCarModel();
        benz.run();

        // 按照同样的顺序，我再要一个宝马
        BMWBuilder bmwBuilder = new BMWBuilder();
        bmwBuilder.setSequence(sequence);
        BMWModel bmw = (BMWModel) bmwBuilder.getCarModel();
        bmw.run();
    }
}

更上一层可以再定义一个 Director 类，负责将 Builder 构建接口的调用封装起来

// 总监掌握各种车型的启动顺序，安排对应的 Builder 构建车型
class Director {
    private ArrayList<String> sequence = new ArrayList<String>();
    private BenzBuilder benzBuilder = new BenzBuilder();
    private BMWBuilder bmwBuilder = new BMWBuilder();

    /*
     * A类型的奔驰车模型，先start，然后stop，其他什么引擎、喇叭一概没有
     */
    public BenzModel getABenzModel() {
        // 清理场景，这里是一些初级程序员不注意的地方
        this.sequence.clear();
        // ABenzModel的执行顺序
        this.sequence.add("start");
        this.sequence.add("stop");
        // 按照顺序返回一个奔驰车
        this.benzBuilder.setSequence(this.sequence);
        return (BenzModel) this.benzBuilder.getCarModel();
    }

    /*
     * B型号的奔驰车模型，是先发动引擎，然后启动，然后停止，没有喇叭
     */
    public BenzModel getBBenzModel() {
        this.sequence.clear();
        this.sequence.add("engine boom");
        this.sequence.add("start");
        this.sequence.add("stop");
        this.benzBuilder.setSequence(this.sequence);
        return (BenzModel) this.benzBuilder.getCarModel();
    }

    /*
     * C型号的宝马车是先按下喇叭（炫耀嘛），然后启动，然后停止
     */
    public BMWModel getCBMWModel() {
        this.sequence.clear();
        this.sequence.add("alarm");
        this.sequence.add("start");
        this.sequence.add("stop");
        this.bmwBuilder.setSequence(this.sequence);
        return (BMWModel) this.bmwBuilder.getCarModel();
    }

    /*
     * D类型的宝马车只有一个功能，就是跑，启动起来就跑，永远不停止
     */
    public BMWModel getDBMWModel() {
        this.sequence.clear();
        this.sequence.add("start");
        this.bmwBuilder.setSequence(this.sequence);
        return (BMWModel) this.benzBuilder.getCarModel();
    }
    /*
     * 这里还可以有很多方法，你可以先停止，然后再启动，或者一直停着不动，静态的嘛
     * 导演类嘛，按照什么顺序是导演说了算
     */
}

有了 Director 类的定义，可以看到客户端代码更加简单，同时整个层次也更加清晰。

import java.util.ArrayList;

public class App {
    public static void main(String[] args) {
        // 让总监负责造车
        Director director = new Director();
        // 1万辆A类型的奔驰车
        for (int i = 0; i < 3; i++) {
            director.getABenzModel().run();
        }
        // 100万辆B类型的奔驰车
        for (int i = 0; i < 3; i++) {
            director.getBBenzModel().run();
        }
        // 1000万辆C类型的宝马车
        for (int i = 0; i < 3; i++) {
            director.getCBMWModel().run();
        }

    }
}

建造者模式的优点

• 封装性
  使用建造者模式可以使客户端不必知道产品内部组成的细节
• 建造者独立，容易扩展
• 便于控制细节风险

建造者模式的使用场景

相同的方法，不同的执行顺序，产生不同的事件结果时，可以采用建造者模式。

多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时，则可以使用该模式。

产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，这个时候使用建造者模式非常合适。

在对象创建过程中会使用到系统中的一些其他对象，这些对象在产品对象的创建过程中不易得到或没有考虑到时，也可以采用建造者模式封装该对象的创建过程。该种场景只能是一个补偿方法，因为一个对象不容易获得，而在设计阶段竟然没有发觉，而要通过创建者模式柔化创建过程，本身已经违反设计的最初目标。

建造者模式的注意事项

建造者模式关注的是零件类型和装配工艺（顺序），这是它与工厂方法模式最大不同的地方，虽然同为创建类模式，但是注重点不同。