用Java实现的设计模式系列（3)--Builder

呵呵，朋友们好，自从开始写《用Java实现的设计模式系列》文章以来，发现自己对于设计模式的理解果然比原来好了很多，这可能是因为用Java来实现设计模式更为贴切和易理解的原因吧。在写这些系列文章时，俺当然参考了网上其它前辈们的源码，对俺最有帮助的就是那本Design Patter In Java,写得很不错，但可惜，里面的例子，俺还是觉得有点复杂。按我的想法，既然设计模式这么难学，所以，刚开始时，对于设计模式的应用，我们只要尽量抓住每个模式最本质的地方，并力求代码尽量简单易懂就好了。至于等到日后你正确理解了设计模式，再去搞复杂的代码也不迟。也许，就是因为当初自己学设计模式学得太苦，所以不希望大家再走我一样的弯路，因此也就有了这个系列文章。希望自己的这个用Java实现的设计模式系列能真正对大家有所帮助。当然，也希望自己能全部写完(呵呵。。先给自己加点劲)。
好了，言归正传，让我们来看看今天的主角----Builder,中文又叫做生成器。
当初我学这个设计模式的时候，怎么都搞不懂它和工厂模式到底有什么区别，而且看了很多别人实现的源代码，似乎都是在模仿工厂模式的实现。并没有突出Builder与Factory的本质差别。实际上，就我的理解，既然Builder和Factory同属创建型模式，那么他们的最大共同点就在于都可以创建类对象，在这点上，不光这两个模式一样，其它创建型模式也一样。但正如我在《深入探索Factory模式与Prototype模式的异同(续)》一文中所说，这些模式，功能上的相似，只是“形似而非神似”。既然这样，那好，下面就让我们能看看Builder和Factory在功能的相似上，存在哪些神韵方面的差别。
首先，也是最重要的一点，就是虽然Builder和Factory都可创建产品，但两者所创建的产品类型完全不一样。Factory创建只能是单一的产品(单一在这指它非复合产品),而Builder所创建的产品是复合产品，即产品本身就是由其它部件产品组成的。举个例子来说，现在要生产一辆车，假设它就只由这三个部分组成：玻璃、轮子、发动机。对于工厂模式来说，他创建后返回的，只能是玻璃，或者轮子，抑或是发动机。不管怎么样，他不能向客户返回一辆完整的汽车，要得到一辆完整的汽车，客户必须自己动手去把这些零部件组装成一辆汽车。从这个意义上来讲，工厂模式中的工厂，只是充当了零件厂的角色。那Builder又是如何创建产品的呢？在Builder模式中，一般不需要、也不充许向客户返回单个部件，他向客户返回的，仅仅就是一部已经完全组装好的汽车成品。对于汽车部件的生产细节，客户不需要、也不应该让他们知道。写到这，我突然想到了组装电脑与品牌电脑的差别，组装电脑虽然价格便宜，且易于改动，但性能没有保证，另外你自己还必须了解很多有关电脑方面的知识；对于品牌电脑，价格贵这点先暂时不说，关键在于他不灵活，但是它的性能可以得到很好保证(由厂家)，这易像我们在Builder的系统端保证部件的质量一样。另外，对于品牌电脑，客户根本不需要了解多少电脑组装方面的知识，就可以把一台电脑抱回家，开机使用了。那么，在实际运用中，你是喜欢做DIY一族呢，还是喜欢稳定有保证的质量呢？好像在我们编著程的这个过程中，我们比较趋向于使用“品牌电脑”。这也就为我们正确使用这两种设计模式提供了一个方向：如果你要生产的产品是由不同部件组成的，你最好使用Builder模式，而非Factory模式。
另外，Builder和Factory的差别，就在于他们所生产部件产品所在产品树的问题。这样说，可能有点拗口。具体来说吧，在工厂模式中，我们知道，一个工厂可以创建多个产品，但一个工厂模式中所创建的某个产品，都会和另一个工厂中所创建的产品在同一棵继承树上。如果大家看过我最早写的《用Java实现的设计模式系列（1)—Factory 》那篇文章,就会记得，我在CFactoryMac中创建了一种产品叫MacRam,而在CFactoryWin中创建了另一种产品叫WinRam,很显然，这两种产品是在同一棵继承树上的。对于它们之所以会出现在同一棵继承树上，是完全由Factory模式本身所决定的。大家如果看过Factory的UMl图，就应该记得，要实现Factory模式，一定要有一个Abstract Product类，具体产品再由它派生出来。好了，说完了Factory,再让我们来看看Builder中是否必这么做！实际上，在Builder模式中，我们只是在Abstract Builder中封装了创建部件的接口，而具体创建了什么部件，不同的实际Builder可能会生产出完全不一样的部件，这样不会存在任何问题，因为，我上面说过，Builder只是向客户返回成品，而不向客户返回具体部件，这样，当然就充许产品的部件按要求随意变化了。再举个例子吧，假如你现在要创建两种风马不相及的东西，例如一种是人，它就只由这几部分组成：脑、身、四肢；另一种是树，也由三个部分组成：根、叶、茎。好了，你现在要用Builder模式创建出这两种产品，能不能做到呢？看看下面的代码就明白了：
interface ABuilder{
public void builderPartA();
public void builderPartB();
public void builderPartC();
}
class CBuilderHuman implements ABuilder {
private Human human;
public CBuilderHuman() {
human=new Human();
}
public void builderPartA(){human.head=new Head()};
public void builderPartB(){human.body=new Body()};
public void builderPartC()(human.limb=new Limb()};
public Human getProduct(){
builderPartA();
builderPartB();
builderPartC();
return human;
}
class CBuilderTree的代码类似，这里就不写了。
再来看客户端代码：
public stacic void main(String[] args) {
CBuilderHuman builderhuman=new CBuilderHuman();
CBuilderTree buildertree=new CBuilderTree();
Human man;
Tree tree;
man=builderman.getProduct();
tree=buildertree.getProduct();
}
看了上面的代码，相信大家对于Factory与Builder的产品树问题已有了清楚的认识。虽然，Builder模式可以创建出风马不相及的产品，但一般我们不会这么做。更常见的运用是部件产品在同一棵继承树上。这样做的原因，大家想想面向对象的本质目的也就明白了。
好了，随手写写，想不到就写了这么一大篇。还是那句话，代码说明一切，那接下来，就让我们来看代码吧！

/**
* Design Pattern In Java
* Name:Builder
* 目的：利用Builder模式创建两种汽车carA和carB
* Car=Glass+Wheel+Engine
* carA=AmericanGlass+JapaneseWheel+ChinaEngine
* carB=JapaneseGlass+AmericanWheel+FranceEngine
* A:abstract
* C:Concret
* Author:blackphoenix
* Modify Date:2002-08-19
*/

/**
* 定义部件Glass的抽象类AClass
* 和两个具体类AmericanGlass、JapaneseGlass
*/

abstract class AGlass{

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

abstract class AWheel{

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

}
class ChineseEngine extends AEngine{
public String toString(){
return "/"Chinese Engine/" ";
}
}
class FranceEngine extends AEngine{
public String toString(){
return "/"France Engine/" ";
}
}

/**
* 定义产品类Car
*/
class Car{
AGlass glass;
AWheel wheel;
AEngine engine;
}

/**
* 定义抽象建造器接口ABuilder
*/
interface ABuilder{
public void buildGlass();
public void buildWheel();
public void buildEngine();
}

/**
* 具体建造器类CBuilderCarA
* carA=AmericanGlass+JapaneseWheel+ChineseEngine
*/
class CBuilderCarA implements ABuilder{
private Car product=null;
public CBuilderCarA(){
product=new Car();
}
public void buildGlass(){
product.glass=new AmericanGlass();
}
public void buildWheel(){
product.wheel=new JapaneseWheel();
}
public void buildEngine(){
product.engine=new ChineseEngine();
}
/**
* 将建造部件的工作封装在getProduct()操作中,主要是为了向客户隐藏实现细节
* 这样，具体建造类同时又起到了一个Director的作用
*/
public Car getProduct(){
buildGlass();
buildWheel();
buildEngine();
return product;
}
}

/**
* 具体建造器类CBuilderCarB
* carB=JapaneseGlass+AmericanWheel+FranceEngine
*/
class CBuilderCarB implements ABuilder{
private Car product;
public CBuilderCarB(){
product=new Car();
}
public void buildGlass(){
product.glass=new JapaneseGlass();
}
public void buildWheel(){
product.wheel=new AmericanWheel();
}
public void buildEngine(){
product.engine=new FranceEngine();
}
/**
* 将建造部件的工作封装在getProduct()操作中,主要是为了向客户隐藏实现细节
* 这样，具体建造类同时又起到了一个Director的作用
*/
public Car getProduct(){
buildGlass();
buildWheel();
buildEngine();
return product;
}
}

/**
* 客户端代码，使用Builder创建两种不同型别的carA和carB
*/
public class Builder{
public static void main(String[] args){
Builder client=new Builder();
Car carA,carB;
CBuilderCarA builderA;
CBuilderCarB builderB;
builderA=new CBuilderCarA();
builderB=new CBuilderCarB();
carA=builderA.getProduct();
carB=builderB.getProduct();
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);
}
}