**英文名称**: Builder Pattern又叫做生成器模式 **定义**:将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。 ## 建造者的一般模式  Product产品类：实现了模板方法模式，也就是有模板方法和基本方法。 Builder类抽象建造者，规范产品的组件，一般是由子类实现 ConcreteBuilder具体建造者，实现抽象类类定义的 所有方法，并返回一个组建好的对象。 Directoer 导演类负责安排已有的模块的顺序，然后告诉Builder开始建造。 该例子只是为了说明 建造者模式的一般模式，并没有实际的开发场景，因此，在实际项目开发环境中，应该灵活应用建造者模式。 ~~~ public class BuilderPattern { public static void main(String[] args) { MyDirector director = new MyDirector(); Product p = director.getProduct(); p.mothod(); } } class Product { //该类可以引入模板模式，也可以为普通的类。 protected void mothod(){ System.out.println("我是产品类中的方法...."); } } abstract class ProductBuilder{ //该类为抽象的建造者类。具体实现方法是由子类来完成的。 public abstract Product getProduct(); } class AProductBuilder extends ProductBuilder{ //该类是建造者抽像类的具体实现类。创建出需要的实例。 private Product p = new Product(); @Override public Product getProduct() { // TODO Auto-generated method stub return this.p; } } class MyDirector{ //该类是指挥者类，主要用与高速创建者类需要创建的对象。 private AProductBuilder apBuilder = new AProductBuilder(); public Product getProduct(){ return this.apBuilder.getProduct(); } } ~~~ **一个例子**： 建造一个生产汽车的模板，具有start(),stop(),alarm(),engineBoom(),run()等方法。 但是现在的需求是，根据用户的要求来生产不同类型的车模。例如，宝马车的模型，按照用户的需求来启动宝马车。  ~~~ public class BuilderTest { public static void main(String[] args) { //使用指挥者，直接构建模板类型的实例 Director director = new Director(); //获取奔驰车实例 BenzModel benz = (BenzModel) director.getA_BenzCarModel(); benz.run(); } } class Director{ private ArrayList<String> sequence = new ArrayList<String>(); private BenzBuilder benzBuilder = new BenzBuilder(); private BMWBuilder bmwBuilder = new BMWBuilder(); /** * 宝马车A的模型 * @return 宝马车的实例 */ public Model getA_BMWCarModel(){ //先将集合中的数据清空 this.sequence.clear(); //为用户定义宝马车的启动方式 sequence.add("start"); sequence.add("alarm"); sequence.add("stop"); this.bmwBuilder.setSequence(sequence); return this.bmwBuilder.getModel(); } /** * 宝马车B的模型 * @return 宝马车B的实例 */ public Model getB_BMWCarModel(){ //先将集合中的数据清空 this.sequence.clear(); //为用户定义宝马车的启动方式 sequence.add("start"); sequence.add("alarm"); sequence.add("engine boom"); sequence.add("stop"); this.bmwBuilder.setSequence(sequence); return this.bmwBuilder.getModel(); } /** * 奔驰车A的模型 * @return 奔驰车的实例 */ public Model getA_BenzCarModel(){ //先将集合中的数据清空 this.sequence.clear(); //为用户定义宝马车的启动方式 sequence.add("start"); sequence.add("alarm"); sequence.add("engine boom"); sequence.add("stop"); this.benzBuilder.setSequence(sequence); return this.benzBuilder.getModel(); } /** * 奔驰车B的模型 * @return 奔驰车的实例 */ public Model getB_BenzCarModel(){ //先将集合中的数据清空 this.sequence.clear(); //为用户定义宝马车的启动方式 sequence.add("start"); sequence.add("alarm"); sequence.add("engine boom"); sequence.add("stop"); this.benzBuilder.setSequence(sequence); return this.benzBuilder.getModel(); } } abstract class Model{ ArrayList<String> sequence = new ArrayList<String>(); //车辆启动 protected abstract void start(); //车辆停止 protected abstract void stop(); //车辆鸣笛 protected abstract void alarm(); //车辆发动机轰鸣 protected abstract void engineBoom(); protected void run(){ Iterator<String> it = sequence.iterator(); while(it.hasNext()){ String str = it.next(); if(str.equalsIgnoreCase("engine boom")){ this.engineBoom(); }else if(str.equalsIgnoreCase("start")){ this.start(); }else if(str.equalsIgnoreCase("alarm")){ this.alarm(); }else{ this.stop(); } } } protected void setSequence(ArrayList<String> sequence){ this.sequence = sequence; } } class BMWModel extends Model{ @Override protected void start() { System.out.println("宝马车启动..."); } @Override protected void stop() { System.out.println("宝马车停止..."); } @Override protected void alarm() { System.out.println("宝马车开始鸣笛..."); } @Override protected void engineBoom() { System.out.println("宝马车发动机轰鸣..."); } } class BenzModel extends Model{ @Override protected void start() { System.out.println("奔驰启动..."); } @Override protected void stop() { System.out.println("奔驰停止..."); } @Override protected void alarm() { System.out.println("奔驰开始鸣笛..."); } @Override protected void engineBoom() { System.out.println("奔驰发动机轰鸣..."); } } abstract class CarBuilder{ //用户自定义车辆启动方式 protected abstract void setSequence(ArrayList<String> sequence); //返回Model类及其子类的实例 protected abstract Model getModel(); } class BenzBuilder extends CarBuilder{ private Model benz = new BenzModel(); @Override protected void setSequence(ArrayList<String> sequence) { this.benz.setSequence(sequence); } @Override protected Model getModel() { // TODO Auto-generated method stub return this.benz; } } class BMWBuilder extends CarBuilder{ private Model bmw = new BMWModel(); @Override protected void setSequence(ArrayList<String> sequence) { // TODO Auto-generated method stub this.bmw.setSequence(sequence); } @Override protected Model getModel() { // TODO Auto-generated method stub return this.bmw; } } ~~~ **Tip:(开发中的小习惯)** 1、this调用当调用本类中的成员变量或方法时，要使用this关键字，以区分本方法中的一个变量 2、super调用，当调用父类的成员变量和方法时，使用super关键字 3、当ArrayList和HashMap如果定义成类的成员变量，那在方法中的调用一定要做一个clear的动作，以防止数据混乱 ## 建造者模式使用场景 1、相同的方法，不同的执行顺序，产生不同的事件结果时，可以采用建造者模式 2、多个部件和零件，都可以装配到一个对象中，到那时产生的运行结果又不相同时，这可以使用该模式 3、产品类十分复杂，或者产品类中的调用顺序不同产生了不同的效能，使用建造者模式