设计模式建造者模式（生成器模式）

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

建造者模式中的4个角色：

Product产品类

　　通常是实现了模板方法模式，也就是有模板方法和基本方法。

Builder抽象建造者

　　规范产品的组建，一般是由子类实现。

ConcreteBuilder具体建造者

　　实现抽象类定义的所有方法，并且返回一个组建好的对象。

Director导演类

负责安排已有模块的顺序，然后告诉Builder开始建造。

下面这个例子就是需要根据不同的方法的调用前后进行对象实例的创建。

产品类：

父类（使用了模板方法模式）：

package pattern.Builder;

import java.util.ArrayList;

public abstract class CarModel {

	private ArrayList<String> sequence = 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 < 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("engin boom")) {
				this.engineBoom();
			}
		}
	}

	final public void setSquuence(ArrayList<String> sequence) {
		this.sequence = sequence;
	}

}

子类1：

package pattern.Builder;

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 engineBoom() {
		System.out.println("Benz engineBoom");
	}

}

子类2：

package pattern.Builder;

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 engineBoom() {
		System.out.println("BMW engineBoom");
	}

}

　Builder抽象建造者类

package pattern.Builder;

import java.util.ArrayList;

public abstract class CarBuilder {

	public abstract void setSequence(ArrayList<String> sequence);
	
	public abstract CarModel getCarModel();
}

ConcreteBuilder具体建造者类

建造者1：

package pattern.Builder;

import java.util.ArrayList;

public class BenzBuilder extends CarBuilder{

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

	@Override
	public CarModel getCarModel() {
		return this.benz;
	}

}

建造者2：

package pattern.Builder;

import java.util.ArrayList;

public class BMWBuilder extends CarBuilder{

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

	@Override
	public CarModel getCarModel() {
		return this.BMW;
	}

}

Director导演类：

package pattern.Builder;

import java.util.ArrayList;

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(sequence);
		return (BenzModel) this.benzBuilder.getCarModel();
	}

	public BenzModel getBBenzModel() {
		this.sequence.clear();
		this.sequence.add("engine boom");
		this.sequence.add("start");
		this.sequence.add("stop");
		this.benzBuilder.setSequence(sequence);
		return (BenzModel) this.benzBuilder.getCarModel();
	}

	public BMWModel getABMWModel() {
		this.sequence.clear();
		this.sequence.add("start");
		this.sequence.add("stop");
		this.benzBuilder.setSequence(sequence);
		return (BMWModel) this.bmwBuilder.getCarModel();
	}

	public BMWModel getBBMWModel() {
		this.sequence.clear();
		this.sequence.add("engine boom");
		this.sequence.add("start");
		this.sequence.add("stop");
		this.benzBuilder.setSequence(sequence);
		return (BMWModel) this.bmwBuilder.getCarModel();
	}

}

通过导演类，为每个方法调用的顺序都创建一个独立的方法，再调用建造者类对方法进行实例化

导演类可以有多个，建造者类也可有多个。

建造者模式的优点：

1、封装性：使用建造者模式可以使客户端不必知道产品内部组成的细节，

2、建造者独立，容易扩展：每个不同类型的建造者都相互独立，对系统的扩展非常有利。

3、便于控制细节风险：由于具体的建造者是独立的，因此可以对建造者过程逐步细化，而不对其他的模块产生任何影响。