Build模式的理解

Builder模式
是为了将构建复杂对象的组装过程和它的创建部件与产品对象分离.注意: [b]是解耦组装过程和创建具体部件[/b].
[b]过程实现使用Director，它仅关心组装部件的过程，不关心每个具体部件的创建。
而Builder则是定义出创建部件的接口，然而具体的创建，则是有ConcreteBuilder
来实现。[/b]
由于在Director使用是Builder接口所以，这样就可以重用创建过程，因为
不同的ConcreteBuilder，虽然创建部件不同相同，但是组装过程却相同。


我们假设，每个汽车都有车轮，发动机等部件组成，如果不使用模式，按照一般的方法，
在构造函数中，创建部件车轮，发动机，并且然后进行了组装。
下面以一辆Polo为例：

public class Polo{
//在构造函数中，创建部件，然后进行组装
public Polo(){
//创建部件
车轮 obj1=new 车轮();
//进行组装部件
this.车轮s.add(obj1);

车轮 obj2=new 车轮();
this.车轮s.add(obj2);
//这里省略其他两个车轮
.................

汽车发动机 objNessan=new 汽车发动机();
this.汽车发动机=objNessan;

}
//汽车的组成部件
public vector 车轮s=new Vector;

public 汽车发动机 汽车发动机 =null;
//这里省略了其他部件和功能函数
.................
}

这就是我们没有使用Builder的方式，这样使构造函数相当的复杂。
因为它负责创建具体的部件如（4个车轮，和一个发动机），然后需要进行组装成为产品Polo.
如果我们再增加一种车的类型HongDa,虽然它们种类不同，具体的部件不同，
但是组装的过程相同和部件的抽象（4个车轮和一个发动机）相同。
[b]这样违背地OO的思想重用，于是我们把组装的过程，和创建部件，从产品的构造中独立出来，[/b]
[b]其实就是简化产品的构造函数，封装成对象，来重用。[/b]
于是我们外部化一个Builder它负责创建汽车部件和组装过程，因为创建的部件不同，如Polo的车轮和HongDa的不同，但是它们的组装过程却是相同的，于是我们先定义，几个方法将由它的具体子类实现，
和一个具体的方法，它负责组装过程。明白的会看出这就是模板方法(Template Method)模式。

//它抽象了创建部件，定义一个骨架方法
public class Builder{
public void builder车轮(int n){};
public void builder发动机(){};

public void director构造过程(){
this.builder车轮(4);
this.builder车轮();
}
}

public class PoloBuilder extends Builder{
private Polo polo=new Polo();
public void builder车轮(int n){
for(int i=0;i<n;i++){
车轮 obj1=new 车轮();
polo.车轮s.add(obj1);
}
}
public void builder发动机(){
汽车发动机 objNessan=new 汽车发动机();
polo.汽车发动机=objNessan;
}
public Polo getProduct(){
return polo;
}
}

[b]其实当builder模式的director角色和builder角色合并得化，它就是template method
模式。[/b][b]抽象方法负责创建部件，具体骨架方法负责组装过程[/b]。这样具体的builder只需实现抽象
方法。

Builder目前负责创建部件和组装过程，如果我们把这两个职责，
再进行划分处理，单独一个负责组装过程，另一个负责创建部件。
因为虽然部件不同，但是过程是相同的。于是抽象出两个类。

//该类负责创建部件，具体的由子类实现
public class Builder{
public void builder车轮(int n){};
public void builder发动机(){};
}
//该类实现组装过程
public class Director{
private Builder builder=null;

public class Director(Builder builder){
this.builder=builder;
}

public void 组装过程(){
builder.builder车轮(4);
builder.builder车轮();
}
}

在Director中使用builder接口，然后按照一定规则进行组装，大家可以
看出这是针对[b]接口进行编程[/b]的体现。我们看具体的builder

public class PoloBuilder extends Builder{
private Polo polo=new Polo();
public void builder车轮(int n){
for(int i=0;i<n;i++){
车轮 obj1=new 车轮();
polo.车轮s.add(obj1);
}
}
public void builder发动机(){
汽车发动机 objNessan=new 汽车发动机();
polo.汽车发动机=objNessan;
}
public Polo getProduct(){
return polo;
}
}

客户端的使用,首先创建具体的builder,然后使用Director

PoloBuilder polobuild=new PoloBuilder();
Director d=new Director(polobuild);
d.组装过程();
Product p=polobuild.getProduct();