设计模式-建造者模式(生成器模式)

ArrayList 或者 HashMap 如果定义为类的成员变量，那么在方法中调用一定要做一个clear()动作，以防止
数据混乱。

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

	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 enginBoom();
		
		final public void run() {
			for (int i=0; i<this.sequence.size(); i++) {
				String actionName = this.sequence.get(i);
				if (actionName.equals("start")) {
					this.start();
				} else if (actionName.equals("stop")) {
					this.stop();
				} else if (actionName.equals("alarm")) {
					this.alarm();
				} else if (actionName.equals("engin boom")) {
					this.enginBoom();
				}
			}
		}

		final public void setSequence(ArrayList<String> sequence) {
			this.sequence = sequence;
		}
		
	}
	
	public class BenzModel extends CarModel {

		@Override
		protected void start() {
			System.out.println("benz start");
		}

		@Override
		protected void stop() {
			System.out.println("benz stop");
		}

		@Override
		protected void alarm() {
			System.out.println("benz alarm");
		}

		@Override
		protected void enginBoom() {
			System.out.println("benz enginBoom");
		}

	}
	
	public class BMWModel extends CarModel {

		@Override
		protected void start() {
			System.out.println("BMW start.");
		}

		@Override
		protected void stop() {
			System.out.println("BMW stop.");
		}

		@Override
		protected void alarm() {
			System.out.println("BMW alarm.");
		}

		@Override
		protected void enginBoom() {
			System.out.println("BMW enginBoom.");
		}

	}
	
	public abstract class CarBuilder {

		public abstract void setSequence(ArrayList<String> sequence);
		
		public abstract CarModel getCarModel();
		
	}
	
	public class BMWBuilder extends CarBuilder {

		private BMWModel bmw = new BMWModel();
		
		@Override
		public void setSequence(ArrayList<String> sequence) {
			this.bmw.setSequence(sequence);
		}

		@Override
		public CarModel getCarModel() {
			return bmw;
		}

	}
	
	public class BenzBuilder extends CarBuilder {

		private BenzModel bezn = new BenzModel();
		
		@Override
		public void setSequence(ArrayList<String> sequence) {
			this.bezn.setSequence(sequence);
		}

		@Override
		public CarModel getCarModel() {
			return bezn;
		}

	}

public class Director {
	private ArrayList<String> sequence = new ArrayList<>();
	private BenzBuilder benzBuilder = new BenzBuilder();
	private BMWBuilder bmwBuilder = new BMWBuilder();
	
	public BenzModel getABenzModel() {
		this.sequence.clear();
		this.sequence.add("start");
		this.sequence.add("stop");
		this.benzBuilder.setSequence(this.sequence);
		
		return (BenzModel) this.benzBuilder.getCarModel();
	}
	
	public BenzModel getBBenzModel() {
		this.sequence.clear();
		this.sequence.add("engineboom");
		this.sequence.add("start");
		this.sequence.add("stop");
		this.benzBuilder.setSequence(this.sequence);
		
		return (BenzModel) this.benzBuilder.getCarModel();
	}
	
	public BMWModel getABMWModel() {
		this.sequence.clear();
		this.sequence.add("start");
		this.sequence.add("stop");
		this.benzBuilder.setSequence(this.sequence);
		
		return (BMWModel) this.bmwBuilder.getCarModel();
	}
	
	public BMWModel getBBMWModel() {
		this.sequence.clear();
		this.sequence.add("engineboom");
		this.sequence.add("start");
		this.sequence.add("stop");
		this.benzBuilder.setSequence(this.sequence);
		
		return (BMWModel) this.bmwBuilder.getCarModel();
	}
}

public class Client {
	
	public static void main(String[] args) {
		Director director = new Director();
		
		for (int i=0; i<100; i++) {
			director.getABenzModel().run();
		}
		
		for (int i=0; i<100; i++) {
			director.getABMWModel().run();
		}
	}
	
}

建造者模式的优点
（1）封装性 使用建造者模式可以是客户端不必知道产品内部组成的细节。
（2）建造者独立、易扩展。
（3）便于控制细节风险。

建造者模式的使用场景
（1）相同的方法，不同的执行顺序，产生不同的时间结果时，可以采用建造者模式
（2）多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时。
（3）产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能。
（3）在对象的创建过程中会使用一系列的其他对象，这些对象在产品对象的创建过程中不易得到，也可以采用
建造者模式封装该对象的创建过程。该种场景只能是一个补偿方法，因为一个对象不容易获取，而在设计
阶段竟然没有发觉，而要通过创建者模式柔化创建过程，本身已经违反了设计的最初目标。

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