学步园

from: http://d02540315.javaeye.com/blog/528836

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

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

Java代码

1. public class Polo{   
2. //在构造函数中，创建部件，然后进行组装   
3. public Polo(){   
4. //创建部件   
5. 车轮 obj1=new 车轮();   
6. //进行组装部件   
7. this.车轮s.add(obj1);   
8.   
9. 车轮 obj2=new 车轮();   
10. this.车轮s.add(obj2);   
11. //这里省略其他两个车轮   
12. .................   
13.   
14. 汽车发动机 objNessan=new 汽车发动机();   
15. this.汽车发动机=objNessan;   
16.   
17. }   
18. //汽车的组成部件   
19. public vector 车轮s=new Vector;   
20.   
21. public 汽车发动机 汽车发动机 =null;   
22. //这里省略了其他部件和功能函数   
23. .................   
24. }  

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个车轮和一个发动机）相同。
这样违背地OO的思想重用，于是我们把组装的过程，和创建部件，从产品的构造中独立出来，
其实就是简化产品的构造函数，封装成对象，来重用。
于是我们外部化一个Builder它负责创建汽车部件和组装过程，因为创建的部件不同，如Polo的车轮和HongDa的不同，但是它们的组装过程却是相同的，于是我们先定义，几个方法将由它的具体子类实现，
和一个具体的方法，它负责组装过程。明白的会看出这就是模板方法(Template Method)模式。

Java代码

1. //它抽象了创建部件，定义一个骨架方法   
2. public class Builder{   
3. public void builder车轮(int n){};   
4. public void builder发动机(){};   
5.   
6. public void director构造过程(){   
7. this.builder车轮(4);   
8. this.builder车轮();   
9. }   
10. }   
11.   
12. public class PoloBuilder extends Builder{   
13. private Polo polo=new Polo();   
14. public void builder车轮(int n){   
15. for(int i=0;i<n;i++){   
16. 车轮 obj1=new 车轮();   
17. polo.车轮s.add(obj1);   
18. }   
19. }   
20. public void builder发动机(){   
21. 汽车发动机 objNessan=new 汽车发动机();   
22. polo.汽车发动机=objNessan;   
23. }   
24. public Polo getProduct(){   
25. return polo;   
26. }   
27. }  

//它抽象了创建部件，定义一个骨架方法
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;
}
}

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

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

Java代码

1. //该类负责创建部件，具体的由子类实现   
2. public class Builder{   
3. public void builder车轮(int n){};   
4. public void builder发动机(){};   
5. }   
6. //该类实现组装过程   
7. public class Director{   
8. private Builder builder=null;   
9.   
10. public class Director(Builder builder){   
11. this.builder=builder;   
12. }   
13.   
14. public void 组装过程(){   
15. builder.builder车轮(4);   
16. builder.builder车轮();   
17. }   
18. }  

//该类负责创建部件，具体的由子类实现
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接口，然后按照一定规则进行组装，大家可以
看出这是针对接口进行编程的体现。我们看具体的builder

Java代码

1. public class PoloBuilder extends Builder{   
2. private Polo polo=new Polo();   
3. public void builder车轮(int n){   
4. for(int i=0;i<n;i++){   
5. 车轮 obj1=new 车轮();   
6. polo.车轮s.add(obj1);   
7. }   
8. }   
9. public void builder发动机(){   
10. 汽车发动机 objNessan=new 汽车发动机();   
11. polo.汽车发动机=objNessan;   
12. }   
13. public Polo getProduct(){   
14. return polo;   
15. }   
16. }  

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

Java代码

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