建造者模式

Builder模式也叫建造者模式或者生成器模式，是由GoF提出的23种设计模式中的一种。Builder模式是一种对象创建型模式之一，用来隐藏复合对象的创建过程，它把复合对象的创建过程加以抽象，通过子类继承和重载的方式，动态地创建具有复合属性的对象。

Builder模式的应用场景
- 对象的创建：Builder模式是为对象的创建而设计的模式
- 创建的是一个复合对象：被创建的对象为一个具有复合属性的复合对象
- 关注对象创建的各部分的创建过程：不同的工厂（这里指builder生成器）对产品属性有不同的创建方法

Builder模式的应用范例

下面我们举个例子来加深我们对Builder模式的理解。
比如我们要通过一个汽车加工厂，组装一辆汽车；汽车由车头，车身，车尾3部分组成；它的基本组装步骤是：
- 组装车头
- 组装车身
- 组装车尾

不管被组装的是吉普车，卡车，还是公交车，它们都可以各自重新定义车头，车身与车尾的组装方法；而通过这些被重新定义的组装方法，通过相同的组装步骤就可以组装具有不同属性的各类汽车了。
通过上面的分析，我们知道，该范例满足Builder模式的应用场景所提到的条件：
- 对象的创建：我们需要创建汽车对象
- 创建的是一个复合对象：我们需要创建的汽车对象是具有车头，车身，车尾等复合属性的复合对象
- 关注对象创建的各部分的创建过程：吉普车，卡车等对车头，车身，车尾的组装方法不尽相同


下面我们用Builder设计模式来抽象以上组装过程：
- CarDirector：汽车组装操作的封装类
- CarBuilder：汽车组装抽象类
- JeepBuilder：吉普车组装类，继承自CarBuilder类。
- Car：汽车类，包括车头，车身，车尾等属性。相当于产品类。由CarBuilder/JeepBuilder等创建。

源代码

1. //汽车类  
2. public class Car {  
3.     //车头  
4.     private String head;  
5.     //车身  
6.     private String body;  
7.     //车尾  
8.     private String tail;  
9.   
10.     public String getBody() {  
11.         return body;  
12.     }  
13.     public void setBody(String body) {  
14.         this.body = body;  
15.     }  
16.     public String getHead() {  
17.         return head;  
18.     }  
19.     public void setHead(String head) {  
20.         this.head = head;  
21.     }  
22.     public String getTail() {  
23.         return tail;  
24.     }  
25.     public void setTail(String tail) {  
26.         this.tail = tail;  
27.     }  
28. }  
29.   
30.   
31. //汽车组装抽象类  
32. public abstract class CarBuilder {  
33.     //组装车头  
34.     public abstract void makeHead();  
35.     //组装车身  
36.     public abstract void makeBody();  
37.     //组装车尾  
38.     public abstract void makeTail();  
39.     //得到被组装好的汽车对象  
40.     public abstract Car getCar();  
41. }  
42.   
43. //吉普车组装类  
44. public class JeepBuilder extends CarBuilder {  
45.     Car car = new Car();  
46.   
47.     //组装车头  
48.     public void makeHead() {  
49.         car.setHead("Jeep head");  
50.     }  
51.     //组装车身  
52.     public void makeBody() {  
53.         car.setHead("Jeep body");  
54.     }  
55.     //组装车尾  
56.     public void makeTail() {  
57.         car.setHead("Jeep tail");  
58.     }  
59.   
60.     public Car getCar() {  
61.         return car;  
62.     }  
63. }  
64.   
65.   
66. //汽车组装操作的封装类：该类封装了对整个汽车的组装操作  
67. public class CarDirector {  
68.     //汽车的组装操作  
69.     public void makeCar(CarBuilder builder) {  
70.         //组装车头  
71.         builder.makeHead();  
72.         //组装车身  
73.         builder.makeBody();  
74.         //组装车尾  
75.         builder.makeTail();  
76.     }  
77. }  
78.   
79. //调用  
80. public class Client {  
81.     public static void main(String[] args) {  
82.         CarDirector director = new CarDirector();  
83.   
84.         //创建吉普车生成器（工厂）  
85.         CarBuilder b = new JeepBuilder();  
86.         //调用CarDirector组装整个汽车  
87.         director.makeCar(b);  
88.   
89.         //得到组装好的汽车  
90.         Car car = b.getCar();  
91.         System.out.println(car.getHead());  
92.         System.out.println(car.getBody());  
93.         System.out.println(car.getTail());  
94.     }  
95. } 
96. 
    

上面演示了吉普车(Jeep)的生产过程，如果需要创建公交车（Bus），我们可以依葫芦画瓢，使用一个继承自CarBuilder的BusBuilder，便可简单地生产一个具有与吉普车不同的车头，车身，车尾的汽车来。