设计模式之《建造者模式》

建造者模式也叫生成器模式其定义如下：

Separate the construction of a complex object from its representation so that the same
construction process can create different representations.（将一个复杂对象的构建与它的表示分

离，使得同样的构建过程可以创建不同的表示。）

在此以生产奔驰模型和宝马模型为例 

类图如下：

package syasuo.jianzaozhe;

import java.util.ArrayList;

/**
 * 抽象的车辆模型·
 * @author Administrator
 *
 */
public abstract class AbstractCarModel {

	private ArrayList arrayList = new ArrayList();
	
	//车辆启动
	protected abstract void start();
	//车辆停止
	protected abstract void stop();
	//车辆鸣笛
	protected abstract void alram();
	//车辆引擎声
	protected abstract void enginBoom();
	
	final public void run(){
		//根据传过来的ArrayList 循环谁在前先执行谁
		for (int i = 0; i < this.arrayList.size(); i++) {
			String action = this.arrayList.get(i);
			if(action.equalsIgnoreCase("start")){
				this.start();
			}else if(action.equalsIgnoreCase("stop")){
				this.stop();
			}else if(action.equalsIgnoreCase("alarm")){
				this.alram();
			}else{
				this.enginBoom();
			}
		}
	}

	//汽车行动的先后顺序
	public void setArrayList(ArrayList arrayList) {
		this.arrayList = arrayList;
	}
	
	
	 
}

package syasuo.jianzaozhe;

/**
 * 奔驰模型
 * @author Administrator
 *
 */
public class BenzModel extends AbstractCarModel{

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

	@Override
	protected void stop() {
		System.out.println("奔驰车停止");
	}
	

	@Override
	protected void alram() {
		System.out.println("奔驰车遇到一条小狗开始鸣笛,小狗听见鸣笛快速跑开了");
	}

	@Override
	protected void enginBoom() {
		System.out.println("奔驰车的引擎嗖嗖嗖");
	}

}

package syasuo.jianzaozhe;

/**
 * 宝马模型
 * @author Administrator
 *
 */
public class BMWModel extends AbstractCarModel{

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

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

	@Override
	protected void alram() {
		System.out.println("宝马车遇到一条哈士奇开始鸣笛，哈士奇以为在逗它玩对着宝马车摇尾巴");
	}

	@Override
	protected void enginBoom() {
		System.out.println("宝马车的引擎声森森森");
	}

}

package syasuo.jianzaozhe;

import java.util.ArrayList;
/**
 * 抽象建造者 --汽车组装者
 * @author Administrator
 *
 */
public abstract class AbstractCarBuilder {

	//传入启动顺序集合
	public abstract void setSequence(ArrayList sequence);
	
	//返回汽车模型
	public abstract AbstractCarModel getCarModel();
}

package syasuo.jianzaozhe;

import java.util.ArrayList;
/**
 * 奔驰汽车建造者
 * @author Administrator
 *
 */
public class BenzBuilder extends AbstractCarBuilder{

	//奔驰汽车模型
	private BenzModel model = new BenzModel();
	
	@Override
	public void setSequence(ArrayList sequence) {
		this.model.setArrayList(sequence);
	}

	@Override
	public AbstractCarModel getCarModel() {
		return this.model;
	}

}

package syasuo.jianzaozhe;

import java.util.ArrayList;
/**
 * 宝马汽车建造者
 * @author Administrator
 *
 */
public class BMWBuilder extends AbstractCarBuilder{

	//宝马汽车模型
	private BMWModel model = new BMWModel();
	
	@Override
	public void setSequence(ArrayList sequence) {
		
		this.model.setArrayList(sequence);
	}

	@Override
	public AbstractCarModel getCarModel() {
		
		return this.model;
	}

}

package syasuo.jianzaozhe;

import java.util.ArrayList;

import syasuo.jianzaozhe.AbstractCarModel;

/**
 * 领导类 领导负责定义不同的产品让建造者建造 
 * 建造者职责只负责建造产品 建造什么样的产品是由领导定义的
 * @author Administrator
 *
 */
public class Director {

	//产品的组织顺序不同 功能性不同
	private ArrayList sequence = new ArrayList();
	
	//导演类和建造者类是聚合关系 
	private BenzBuilder benzBuilder = new BenzBuilder();
	private BMWBuilder bmwBuilder = new BMWBuilder();
	
	/*定义奔驰A型车*/
	public AbstractCarModel getBenzACarModel(){
		this.sequence.clear();
		this.sequence.add("start");
		this.sequence.add("stop");
		this.benzBuilder.setSequence(sequence);
		return this.benzBuilder.getCarModel();
	}
	
	/*定义奔驰B型车*/
	public AbstractCarModel getBenzBCarModel(){
		this.sequence.clear();
		this.sequence.add("alarm");
		this.sequence.add("start");
		this.sequence.add("stop");
		this.benzBuilder.setSequence(sequence);
		return this.benzBuilder.getCarModel();
	}
	
	/*定义宝马A型车*/
	public AbstractCarModel getBMWACarModel(){
		this.sequence.clear();
		this.sequence.add("start");
		this.sequence.add("alarm");
		this.sequence.add("stop");
		this.bmwBuilder.setSequence(sequence);
		return this.bmwBuilder.getCarModel();
	}
	
	/*定义宝马B型车*/
	public AbstractCarModel getBMWBCarModel(){
		this.sequence.clear();
		this.sequence.add("start");
		this.sequence.add("engineBoom");
		this.sequence.add("alarm");
		this.sequence.add("stop");
		this.bmwBuilder.setSequence(sequence);
		return this.bmwBuilder.getCarModel();
	}
} 

package syasuo.jianzaozhe;

import syasuo.jianzaozhe.Director;

public class Main {

	public static void main(String[] args) {
		
			Director director = new Director();
			System.out.println("---------生产---------奔驰A型车--------------------------------");
			for (int i = 0; i < 2; i++) {
				director.getBenzACarModel().run();
			}
			System.out.println("---------生产---------奔驰B型车--------------------------------");
			for (int i = 0; i < 3; i++) {
				director.getBenzBCarModel().run();
			}
			System.out.println("---------生产---------宝马A型车--------------------------------");
			for (int i = 0; i < 2; i++) {
				director.getBMWACarModel().run();
			}
			System.out.println("---------生产---------宝马B型车--------------------------------");
			for (int i = 0; i < 3; i++) {
				director.getBMWBCarModel().run();
		}
	}
}

建造者模式的使用场景：

一、相同的方法，不同的执行顺序，产生不同的事件结果时，可以使用建造者模式

二、多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不想同时可使用此模式

三、产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能可以使用

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

建造者模式最主要的功能是基本方法的调用顺序安排，

也就是这些基本方法已经实现了，通俗地说就是零件的装配，顺序不同产生

的对象也不同；而工厂方法则重点是创建，创建零件是它的主要职责，组装顺序则不是它关
心的。