JAVA设计模式-Builder （生成器 ）

   Builder设计模式类似于Factory，都是用于生产一种产品，但是他们之间还是有一些区别的。至于有什么区别，仁者见仁，智者见智，我会在介绍完Builder模式之后说说我自己的看法，当然我的想法也参考了很多其他人的看法。下面先看一个例子吧：

 

    当要生产的一种产品具有相同的结构，并且每个构件的生产都很繁杂，就可以用Builder模式将具体构件的生产与整个成品的组装分离开来。还是拿本文的代码来举例，生产一辆汽车，生产汽车的厂家不需要知道引擎怎么生产的，不需要关心轮胎怎么生产的，也不需要关心玻璃怎么生产的。当他在生产一辆车的时候，只会说，我要一块日本产的引擎，于是就有了日本产的引擎（至于日本引擎怎么生产的他不关心，他只要一个引擎的成品），他又说我要一块美国产的玻璃，于是就有了美国产的玻璃，这样直到他得到了所有的构件，然后他把这些构件组装起来，组成一个成品（汽车）卖给客户。这就是一个典型的Builder模式。下面是代码：

 

package builder;
/**
 * design pattern in java
 * name:builder
 * 目的：利用builder模式创建两种汽车carA和carB
 * car=glass+wheel+engine
 * carA=AmericanGlass+JapaneseWheel+ChinaEngine
 * carB=JapaneseGlass+AmericanWheel+FranceEngine
 * author:blackphoenix
 * create date:2002-08-19
 * modifier:Anyuan Zhao
 * modify date:2011-02-16
 */

/**
 * 定义部件glass的抽象类Glass
 * 和两个具体类AmericanGlass、JapaneseGlass
 */
abstract class Glass{
}
class AmericanGlass extends Glass{
	public String toString(){
		return "/"American Glass/" ";
	}
}
class JapaneseGlass extends Glass{
	public String toString(){
		return "/"Japanese Glass/" ";
	}
}

/**
 * 定义部件wheel的抽象类Wheel
 * 和两个具体类AmericanWheel、JapaneseWheel
 */
abstract class Wheel{
}
class AmericanWheel extends Wheel{
	public String toString(){
		return "/"American Wheel/" ";
	}
}
class JapaneseWheel extends Wheel{
	public String toString(){
		return "/"Japanese Wheel/" ";
	}
}

/**
 * 定义部件engine的抽象类Engine
 * 和两个具体类ChineseEngine、FranceEngine
 */
abstract class Engine{
}
class ChineseEngine extends Engine{
	public String toString(){
		return "/"Chinese Engine/" ";
	}
}
class FranceEngine extends Engine{
	public String toString(){    
		return "/"France Engine/" ";
	}
}

/**
 * 定义产品类Car
 */
class Car{
	Glass glass;
	Wheel wheel;
	Engine engine;
}
/**
 * 定义抽象建造器接口Builder
 */

interface CarBuilder{
	public void buildGlass();
	public void buildWheel();
	public void buildEngine();
	public Car getProduct();
}

/**
 * 具体建造器类CarABuilder
 * CarA=AmericanGlass+JapaneseWheel+ChineseEngine
 */
class CarABuilder implements CarBuilder{
	private Car product=null;
	public CarABuilder(){
		product=new Car();
	}
	/**
	 * 将建造部件的工作封装在getProduct()操作中,主要是为了向客户隐藏实现细节
	 * 这样，具体建造类同时又起到了一个director的作用
	 */
	@Override
	public void buildEngine() {
		// TODO Auto-generated method stub
		product.engine=new ChineseEngine();
	}
	@Override
	public void buildGlass() {
		// TODO Auto-generated method stub
		product.glass=new AmericanGlass();
	}
	@Override
	public void buildWheel() {
		// TODO Auto-generated method stub
		product.wheel=new JapaneseWheel();
	}
	@Override
	public Car getProduct() {
		// TODO Auto-generated method stub
		buildGlass();
		buildWheel();
		buildEngine();
		return product;
	}
}
/**
 * 具体建造器类CarABuilder
 * CarB=JapaneseGlass+AmericanWheel+FranceEngine
 */
class CarBBuilder implements CarBuilder{
	private Car product;
	public CarBBuilder(){
		product=new Car();
	}
	/**
	 * 将建造部件的工作封装在getProduct()操作中,主要是为了向客户隐藏实现细节
	 * 这样，具体建造类同时又起到了一个director的作用
	 */
	@Override
	public void buildEngine() {
		// TODO Auto-generated method stub
		product.engine=new FranceEngine();
	}
	@Override
	public void buildGlass() {
		// TODO Auto-generated method stub
		product.glass=new JapaneseGlass();
	}
	@Override
	public void buildWheel() {
		// TODO Auto-generated method stub
		product.wheel=new AmericanWheel();
	}
	@Override
	public Car getProduct() {
		// TODO Auto-generated method stub
		buildGlass();
		buildWheel();
		buildEngine();
		return product;
	}
}
class Director{
	private CarBuilder builder; 
	public Director(CarBuilder builder) { 
		this.builder = builder; 
	}
	public Car construct() { 
		return builder.getProduct();
	} 
}
/**
 * 客户端代码，使用Director创建两种不同型别的CarA和CarB
 */
public class Test{
	public static void main(String[] args){
		Car carA,carB;
		CarBuilder builderA = new CarABuilder();
		CarBuilder builderB = new CarBBuilder();
		Director director;
		director = new Director(builderA);
		carA=director.construct();
		director = new Director(builderB);
		carB=director.construct();
		System.out.println("Car A is made by:"+carA.glass+carA.wheel+carA.engine);
		System.out.println("Car B is made by:"+carB.glass+carB.wheel+carB.engine);
	}
}

这个代码的运行结果：

    Car A is made by:"American Glass" "Japanese Wheel" "Chinese Engine"

    Car B is made by:"Japanese Glass" "American Wheel" "France Engine"

 

    首先要解释一下toString()这个方法（和Builder模式无关，只是顺带提一下），他是重载了Object的toString()方法，当使用System.out.println(object)的时候，就会隐式调用object的toString()方法。

 

    解释下代码，在main函数里面，director调用了builder里面的getProduct()方法，getProduct()方法实际就是组装的过程，getProduct()里面的buildGlass()，buildWheel()，buildEngine()就是在购买构件，而这些构件生产的具体过程放在了这些构件自身的类里面，可以看到buildGlass()里面有new一个对象，这就是在进行生产。这样就达到了组装和生产构件之间的分离。

 

    最后，说说我对Builder模式和Factory模式之间区别的理解。我个人认为Builder和Factory之间的区别就是组装和生产之间的区别，Builder着重将组装和构件的生产分离，Factory着重于优化生产的过程。本文的代码实际上还可以进行重构，例如，在buildGlass()函数里面，用到了new这个关键字，实际上可以将这个new换成工厂类，让工厂类来生产Glass。换一种说法，就是Factory不进行组装，Builder进行组装，当Factory进行组装的时候，它就变成Builder了。

 

    我也不知道我说清楚没，这只是我个人看法而已，仅供参考，不是标准答案。