设计23式—建造者

最近在看设计模式之禅，书的内容以讲故事的方式介绍了设计模式，强力推荐。

以下是个人对于建造者模式的理解

/*
 * 建筑者模式
 * 优点
 * 封装性好
 * 建造者独立，容易扩展
 * 便于控制细节风险
 */
public class MyMain {

	public static void main(String[] args) {
		// 创建一个导演对象
		Director director = new Director();
		// 要求导演对象创建A类车型号1000,A类车型号2000,B类车型号1000,B类车型号2000
		director.getCarA1000().test();
		System.out.println("--------------------------");
		director.getCarA2000().test();
		System.out.println("--------------------------");
		director.getCarB1000().test();
		System.out.println("--------------------------");
		director.getCarB2000().test();
	}

}

// 定义抽象车模型
abstract class CarModel {
	// 定义测试顺序
	ArrayList<String> sequence = new ArrayList<>();

	// 基本抽象方法：启动
	protected abstract void start();

	// 基本抽象方法：暂停
	protected abstract void stop();

	// 基本抽象方法：奔跑
	protected abstract void run();

	// 模板方法 测试
	protected void test() {
		System.out.println("开始测试");
		// 遍历sequence，根据顺序测试
		for (String action : sequence) {
			if (action.equals("start"))
				start();
			if (action.equals("stop"))
				stop();
			if (action.equals("run"))
				run();
		}
		System.out.println("测试结束");
	}
	// 设置测试顺序
	protected void setSequence(ArrayList<String> sequence) {
		this.sequence = sequence;
	}
}

// 继承车模型的A类车
class CarA extends CarModel {

	@Override
	protected void start() {
		System.out.println("A类车启动");
	}

	@Override
	protected void stop() {
		System.out.println("A类车暂停");
	}

	@Override
	protected void run() {
		System.out.println("A类车奔跑");
	}

}

// 继承车模型的B类车
class CarB extends CarModel {
	@Override
	protected void start() {
		System.out.println("B类车启动");
	}

	@Override
	protected void stop() {
		System.out.println("B类车暂停");
	}

	@Override
	protected void run() {
		System.out.println("B类车奔跑");
	}
}

// 定义抽象的车模型建造者
abstract class CarModelBuilder {
	// 设定车模型的测试顺序
	public abstract void setSequence(ArrayList<String> sequence);

	// 获得建造的车模型
	public abstract CarModel getCarModel();
}

// 继承抽象车模型建筑者的A类车模型建筑者
class CarABuilder extends CarModelBuilder {
	CarModel carA = new CarA();

	@Override
	public void setSequence(ArrayList<String> sequence) {
		carA.setSequence(sequence);
	}

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

// 继承抽象车模型建筑者的B类车模型建筑者
class CarBBuilder extends CarModelBuilder {
	CarModel carB = new CarB();

	@Override
	public void setSequence(ArrayList<String> sequence) {
		carB.setSequence(sequence);
	}

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

// 导演类
class Director {
	// 测试顺序
	private ArrayList<String> sequence = new ArrayList<>();
	// A类车建造者
	private CarModelBuilder carABuilder = new CarABuilder();
	// B类车建造者
	private CarModelBuilder carBBuilder = new CarBBuilder();

	// 获得A类车型号1000 该车测试顺序为 1启动 2暂停
	public CarA getCarA1000() {
		sequence.clear();
		sequence.add("start");
		sequence.add("stop");
		carABuilder.setSequence(sequence);
		// 向下转行
		return (CarA) carABuilder.getCarModel();
	}

	// 获得A类车型号2000 该车测试顺序为 1启动 2暂停 3启动 4 奔跑
	public CarA getCarA2000() {
		sequence.clear();
		sequence.add("start");
		sequence.add("stop");
		sequence.add("start");
		sequence.add("run");
		carABuilder.setSequence(sequence);
		// 向下转行
		return (CarA) carABuilder.getCarModel();
	}

	// 获得B类车型号1000 该车测试顺序为 1 启动 2 奔跑
	public CarB getCarB1000() {
		sequence.clear();
		sequence.add("start");
		sequence.add("run");
		carBBuilder.setSequence(sequence);
		// 向下转行
		return (CarB) carBBuilder.getCarModel();
	}

	// 获得B类车型号2000 该车测试顺序为 1 启动 2 奔跑 3暂停
	public CarB getCarB2000() {
		sequence.clear();
		sequence.add("start");
		sequence.add("run");
		sequence.add("stop");
		carBBuilder.setSequence(sequence);
		// 向下转行
		return (CarB) carBBuilder.getCarModel();
	}
}