建造者模式

What

Separate the construction ofa complex object from its representation so that the same construction process can create different representations.（将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。）

why

封装性 使用建造者模式可以使客户端不必知道产品内部组成的细节
建造者独立，容易扩展BenzBuilder和BMWBuilder是相互独立的，对系统的扩展非常有利。
    便于控制细节风险由于具体的建造者是独立的， 因此可以对建造过程逐步细化， 而不对其他的模块产生任何影响。
相同的方法，不同的执行顺序，产生不同的事件结果时，可以采用建造者模式。
多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时，则可以使用该模式。
产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，这个时候使用建造者模式非常合适。
在对象创建过程中会使用到系统中的一些其他对象，这些对象在产品对象的创建过程
中不易得到时， 也可以采用建造者模式封装该对象的创建过程。该种场景只能是一个补偿方法，因为一个对象不容易获得，而在设计阶段竟然没有发觉，而要通过 创建者模式柔化创建过程，本身已经违反设计的最初目标。

how

产品类

public class Product {
	public void doSomething( ) {
		//独立业务处理
	}
}

抽象建造者

public abstract class Builder {
	//设置产品的不同部分， 以获得不同的产品
	public abstract void setPart( ) ;
	//建造产品
	public abstract Product buildProduct( ) ;
}

具体建造者

public class ConcreteProduct extends Builder {
	private Product product = new Product( ) ;
	//设置产品零件
	public void setPart( ) {
		/*
		* 产品类内的逻辑处理
		*/
	}
	//组建一个产品
	public Product buildProduct( ) {
		return product;
	}
}

导演类

public class Director {
	private Builder builder = new ConcreteProduct( ) ;
	//构建不同的产品
	public Product getAProduct( ) {
		builder.setPart( ) ;
		/*
		* 设置不同的零件， 产生不同的产品
		*/
		return builder.buildProduct( ) ;
	}
}

extension

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

建造者模式 + 模板方法

模型的抽象类

public 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 sequence) {
	this. sequence = sequence;
	}
}

具体模型代码

public 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( "奔驰车应该这样停车. . . " ) ;
	}
}

抽象组装者

public abstract class CarBuilder {
	//建造一个模型， 你要给我一个顺序要求， 就是组装顺序
	public abstract void setSequence( ArrayList<String> sequence) ;
	//设置完毕顺序后， 就可以直接拿到这个车辆模型
	public abstract CarModel getCarModel( ) ;
}

具体组装者

public 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) ;
	}
}

导演类

public class Director {
	private ArrayList<String> sequence = new ArrayList( ) ;
	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( ) ;
	}
	/*
	这里还可以有很多方法， 你可以先停止， 然后再启动， 或者一直停着不动， 静态的嘛
	* 导演类嘛， 按照什么顺序是导演说了算
	*/
}

建造者模式最主要的功能是基本方法的调用顺序安排， 也就是这些基本方法已经实现了， 通俗地说就是零件的装配， 顺序不同产生的对象也不同； 而工厂方法则重点是创建， 创建零件是它的主要职责， 组装顺序则不是它关心的。