也称为：生成器模式
定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

建造者模式通用类图：

建造者模式 .png

在建造者模式中通常有四个角色：
①Product产品类：通常是实现了模板方法模式，也就是有模板方法与基本方法。
②Builder抽象建造者：规范产品的组建，由其子类实现。
③ConcreteBuilder子类建造者：实现抽象建造者的方法，并返回一个组建好的对象。
④Director导演类：起到封装作用，避免高层模块深入到建造者内部的实现类，负责安排已有模块的组建，然后告诉Builder开始建造，可以有多个导演类。

问题重现：
现在需要建造车辆模型，车有：启动（start），停止（stop），喇叭（alarm），引擎启动（engineBoom）四种行为，现在需要根据用户需求，自定义这四种行为，并生产对应的车辆模型。

（1）产品抽象类

public abstract class CarModel {
    //记录自定义车辆模型的行为顺序
   private ArrayList<String> abstractArrayList = new ArrayList<>();
    //车辆启动行为
   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<abstractArrayList.size();i++){
         if (Objects.equals(abstractArrayList.get(i),"start")){
            this.start();
         }
         if (Objects.equals(abstractArrayList.get(i),"stop")){
            this.stop();
         }
         if (Objects.equals(abstractArrayList.get(i),"alarm")){
            this.alarm();
         }
         if (Objects.equals(abstractArrayList.get(i),"engineBoom")){
            this.engineBoom();
         }
      }
   }
    //在抽象类中完成传递用户定义好的顺序
   protected void setArrayList(ArrayList arrayList){
      this.abstractArrayList = arrayList;
   }
}

（2）产品实现类

public class BMWCar extends CarModel{
    //子类重写基本方法
   @Override
   protected void start() {
      System.out.println("start 开始");
   }
   
   @Override
   protected void stop() {
      System.out.println("stop 开始");
   }
   
   @Override
   protected void alarm() {
      System.out.println("alarm 开始");
   }
   
   @Override
   protected void engineBoom() {
      System.out.println("engineBoom 开始");
   }
}

经过上述两部分，已经将产品类的模板方法与基本方法完成。

（3）抽象建造者

public abstract class CarBuilder {
   //根据用户提供的模块顺序搭建汽车
   abstract CarModel getCar(ArrayList<String> arrayList);
}

（4）具体的子类建造者

public class BMWCarBuilder extends CarBuilder {
   @Override
   CarModel getCar(ArrayList<String> arrayList) {
      BMWCar bmwCar = new BMWCar();
      bmwCar.setArrayList(arrayList);
      return bmwCar;
   }
}

（5）导演类

public class Director {
   private  ArrayList<String> abstractArrayList = new ArrayList<>();
   private  BMWCarBuilder bmwCarBuilder = new BMWCarBuilder();
   
   public BMWCar getBMWCar( ){
      //清理集合数据，防止数据混乱
      this.abstractArrayList.clear();
      abstractArrayList.add("start");
      abstractArrayList.add("stop");
      abstractArrayList.add("alarm");
      return (BMWCar) bmwCarBuilder.getCar(abstractArrayList);
   }
   
}
------------output--------------
start 开始
stop 开始
alarm 开始

经过上述代码，用户可以在导演类中自定义车辆模型的行为顺序，然后建造对应的车辆模型。

建造者模式的优点：
①封装性。
②建造者独立，扩展方便。
③由于建造者是独立的，可以对建造过程进行细化，便于控制细节风险，且不会对其他模块造成影响。

建造者模式的使用场景：
①相同的方法，不同的执行顺序，产生不同的事件结果。
②多个部件组装到一个对象中，运行结果不同时。

建造者模式的注意点：
建造者模式注重零件类型和装配工艺顺序，而不是注重创建对象；工厂方法模式注重的是部件或对象的创建，组装顺序并不是它所关心的。

参考书籍：设计模式之禅 --- 秦小波 著