英文名称: 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、产品类十分复杂，或者产品类中的调用顺序不同产生了不同的效能，使用建造者模式