设计模式二：建造模式

建造者模式的通用类图如图：

本例类图：

1.从测试类开始

package com.bestaone.pattern.builder;

/**
 * 定义：
 * GOF给建造模式的定义为：将一个复杂对象的构建与它的表示分离，
 * 使得同样的构建过程可以创建不同的表示。
 * 可以将建造模式的精髓概括为：将构造复杂对象的过程和对象的部件解耦。
 * 这是对降低耦合、提高可复用性精神的一种贯彻。
 * 
 * 使用场景：
 * 这个建造者模式和工厂模式非常相似呀，Yes，是的，是非常相似，
 * 但是记住一点你就可以游刃有余的使用了：建造者模式最主要功能是基本方法的调用顺序安排，
 * 也就是这些基本方法已经实现了，通俗的说就是零件的装配，
 * 顺序不同产生的对象也不同；而工厂方法则重点是创建，
 * 创建零件时它的主要职责，你要什么对象我创造一个对象出来，组装顺序则不是他关心的。
 * 
 * @author 张国圣
 */
public class Test {


	public static void main(String[] args) {
		
		Director director = new Director();

		//100辆A类型的奔驰车
		for (int i = 0; i < 100; i++) {
			director.getABenz().run();
		}

		//100辆B类型的奔驰车
		for (int i = 0; i < 100; i++) {
			director.getBBenz().run();
		}

		//100辆C类型的宝马车
		for (int i = 0; i < 100; i++) {
			director.getCBmw().run();
		}
		
	}

}

2.产品几类

package com.bestaone.pattern.builder;

import java.util.ArrayList;

public abstract class Car {

	//这个参数是各个基本方法执行的顺序
	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<String> sequence) {
		this.sequence = sequence;
	}

}

3.产品类奔驰

package com.bestaone.pattern.builder;

/**
 *产品类: 通常是实现了模板方法模式，也就是有模板方法和基本方法
 */
public class Benz extends Car {

	@Override
	protected void alarm() {
		System.out.println("奔驰车的喇叭声音是这个样子的...");
	}

	@Override
	protected void engineBoom() {
		System.out.println("奔驰车的引擎室这个声音的...");
	}

	@Override
	protected void start() {
		System.out.println("奔驰车跑起来是这个样子的...");
	}

	@Override
	protected void stop() {
		System.out.println("奔驰车应该这样停车...");
	}

}

4.产品类宝马

package com.bestaone.pattern.builder;

/**
 *产品类: 通常是实现了模板方法模式，也就是有模板方法和基本方法
 */
public class Bmw extends Car {

	@Override
	protected void alarm() {
		System.out.println("宝马车的喇叭声音是这个样子的...");
	}

	@Override
	protected void engineBoom() {
		System.out.println("宝马车的引擎室这个声音的...");
	}

	@Override
	protected void start() {
		System.out.println("宝马车跑起来是这个样子的...");
	}

	@Override
	protected void stop() {
		System.out.println("宝马车应该这样停车...");
	}

}

5.建造者

package com.bestaone.pattern.builder;

import java.util.ArrayList;

/**
 * 抽象建造者:规范产品的组建，一般是由子类实现。
 */
public abstract class CarBuilder {

	//建造一个模型，你要给我一个顺序要，就是组装顺序
	public abstract void setSequence(ArrayList<String> sequence);

	//设置完毕顺序后，就可以直接拿到这个车辆模型
	public abstract Car getCar();

}

6.宝马建造者

package com.bestaone.pattern.builder;

import java.util.ArrayList;

/**
 * 具体建造者:实现抽象类定义的所有方法，并且返回一个组件好的对象。
 */
public class BmwBuilder extends CarBuilder {

	private Bmw bmw = new Bmw();

	@Override
	public Car getCar() {
		return this.bmw;
	}

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

}

7.奔驰建造者

package com.bestaone.pattern.builder;

import java.util.ArrayList;

/**
 * 具体建造者:实现抽象类定义的所有方法，并且返回一个组件好的对象。
 */
public class BenzBuilder extends CarBuilder {

	private Benz benz = new Benz();

	@Override
	public Car getCar() {
		return this.benz;
	}

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

}

8.导演类

package com.bestaone.pattern.builder;

import java.util.ArrayList;

/**
 * 导演:负责安排已有模块的顺序，然后告诉Builder开始建造
 */
public class Director {

	private ArrayList<String> sequence = new ArrayList<String>();

	private BenzBuilder benzBuilder = new BenzBuilder();

	private BmwBuilder bmwBuilder = new BmwBuilder();

	/*
	* A类型的奔驰车模型，先start,然后stop,其他什么引擎了，喇叭一概没有
	*/
	public Benz getABenz() {
		//清理场景，这里是一些初级程序员不注意的地方
		this.sequence.clear();
		//这只ABenzModel的执行顺序
		this.sequence.add("start");
		this.sequence.add("stop");
		//按照顺序返回一个奔驰车
		this.benzBuilder.setSequence(this.sequence);
		return (Benz) this.benzBuilder.getCar();
	}

	/*
	* B型号的奔驰车模型，是先发动引擎，然后启动，然后停止，没有喇叭
	*/
	public Benz getBBenz() {
		this.sequence.clear();
		this.sequence.add("engine boom");
		this.sequence.add("start");
		this.sequence.add("stop");
		this.benzBuilder.setSequence(this.sequence);
		return (Benz) this.benzBuilder.getCar();
	}

	/*
	* C型号的宝马车是先按下喇叭（炫耀嘛），然后启动，然后停止
	*/
	public Bmw getCBmw() {
		this.sequence.clear();
		this.sequence.add("alarm");
		this.sequence.add("start");
		this.sequence.add("stop");
		this.bmwBuilder.setSequence(this.sequence);
		return (Bmw) this.bmwBuilder.getCar();
	}

	/*
	* D类型的宝马车只有一个功能，就是跑，启动起来就跑，永远不停止，牛叉
	*/
	public Bmw getDBmw() {
		this.sequence.clear();
		this.sequence.add("start");
		this.bmwBuilder.setSequence(this.sequence);
		return (Bmw) this.benzBuilder.getCar();
	}

	/*
	* 这里还可以有很多方法，你可以先停止，然后再启动，或者一直停着不动，静态的嘛
	* 导演类嘛，按照什么顺序是导演说了算
	*/

}