建造者模式

　　如果需要将一个复杂对象的构建与它的表示层分离，使得同样的构建过程可以创建不同的表示的意图时，我们就需要用到建造者模式了，又叫生成器模式。建造者模式可以将一个产品的内部表象与产品的生产过程分割开来，从而可以使一个建造过程生成具有不同内部表象的产品对象。如果我们使用了建造者模式，那么用户只需要指定需要建造的类型就可以得到他们，而具体的建造过程和细节就不需要知道了。

　　我们来看建造者模式的概念，将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

　　那么，什么时候需要建造者模式呢？

　　它主要是用于创建一些复杂的对象，这些对象内部构建间的建造顺序通常是稳定的，但对象内部的构建通常面临这复杂的变化。

　　我们来看代码，首先是产品类：

　　

 1 package builder;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 public class Product {
 7     private List<String> parts = new ArrayList<String>();
 8     
 9     public void addPart(String part){
10         parts.add(part);
11     }
12 
13     public void show(){
14         for(String part:parts){
15             System.out.println("部件："+part);
16         }
17     }
18 }

抽象的builder类，抽象出建造产品的流程，并提供展示结果的抽象方法：

1 public abstract class Builder {
2     public abstract void buildPartA();
3 
4     public abstract void buildPartB();
5 
6     public abstract Product getResult();
7 }

然后是具体的builder：

View Code 
 1 public class ConcreteBuilderA extends Builder{
 2     
 3     private Product product = new Product();
 4     
 5     @Override
 6     public void buildPartA() {
 7         product.addPart("部件A");
 8     }
 9 
10     @Override
11     public void buildPartB() {
12         product.addPart("部件B");
13     }
14 
15     @Override
16     public Product getResult() {
17         return product;
18     }
19     
20 }
21 
22 public class ConcreteBuilderB extends Builder{
23 
24     private Product product = new Product();
25     
26     @Override
27     public void buildPartA() {
28         product.addPart("部件X");
29     }
30 
31     @Override
32     public void buildPartB() {
33         product.addPart("部件Y");
34     }
35 
36     @Override
37     public Product getResult() {
38         return product;
39     }
40     
41 }

指挥着，隐藏具体的建造者，让客户端决定使用哪个建造者：

1 public class Derector {
2     public void construct(Builder builder){
3         builder.buildPartA();
4         builder.buildPartB();
5     }
6 }

客户端调用：

 1 public class Main {
 2     public static void main(String[] args) {
 3         Derector derector = new Derector();
 4         Builder builderA = new ConcreteBuilderA();
 5         Builder builderB = new ConcreteBuilderB();
 6         
 7         derector.construct(builderA);
 8         Product p1 = builderA.getResult();
 9         p1.show();
10         
11         derector.construct(builderB);
12         Product p2 = builderB.getResult();
13         p2.show();
14     }
15 }

　　我们来总结一下：建造者模式是在当创建复杂对象的算法应该独立于该对象的组成部分以及他们的装配方式时使用的模式。

posted @ 2012-10-26 11:29  寒剑飘香  阅读(179)  评论(0)    收藏  举报