設計模式：04-生成器（Builder）

在軟件的構建過程當中，面臨一個複雜對象的建立工做，每一個部分的子對象都使用必定的算法構成。可是因爲需求不斷的變更，每一個部分子對象的算法會隨之而改變，可是總體的構建過程卻保持相對的穩定性。在面向對象的設計過程當中，如何應對這種變化？

好比在某個遊戲場景中，須要構建一個房屋，構建房屋所須要的組件包括：窗戶、屋頂、門、牆和地板。在通常的狀況下，咱們會這樣去設計類之間的關係：

如今需求須要改變了，須要遊戲添加一種新的場景——現代風格的房屋。這時候就將以前風格的窗戶、屋頂、門、牆和地板都替換爲現代的風格。這時候就面臨着各類部件的變更，而相對的，房子整的構建過程不會改變，並且房子的構建過程比較複雜。上述的方案根本沒法適應這種需求的改變，只能從新寫BuildHouse類。那麼咱們應該如何的去設計類，儘量的去複用房屋構建的算法（即不用重寫BuildHouse），而不須要進行從新寫？

在《設計模式》那本書中，提出了生成器的設計模式，該模式的意圖就是將一個複雜對象的構建過程與其表示分離，是的相同的構建過程能夠呈現不一樣的展現。這種設計模式剛好符合咱們這種需求的變更，即複雜對象各個部分之間的變化。生成器模式類的結構圖以下：

根據生成器模式，下面是從新設計的類：

接下來是相關代碼的實現：

一、首先是House部分的類，該部分是具體建立某一些組件的類。

 1 public abstract class House {
 2     /* abstract build the window */
 3     public abstract void buildWindow();
 4 
 5     /* abstract build the door */
 6     public abstract void buildDoor();
 7 
 8     /* abstract build the floor */
 9     public abstract void buildFloor();
10 
11     /* abstract build the Ceiling */
12     public abstract void buildCeiling();
13 
14     /* abstract build the Wall */
15     public abstract void buildWall();
16 }
17 
18 public class ClassicHouse extends House {
19     /* abstract build the window */
20     public void buildWindow() {}
21 
22     /* abstract build the door */
23     public void buildDoor() {}
24 
25     /* abstract build the floor */
26     public void buildFloor() {}
27 
28     /* abstract build the Ceiling */
29     public void buildCeiling() {}
30 
31     /* abstract build the Wall */
32     public void buildWall() {}
33 }
34 
35 public class ModenHouse extends House {
36     /* abstract build the window */
37     public void buildWindow() {}
38 
39     /* abstract build the door */
40     public void buildDoor() {}
41 
42     /* abstract build the floor */
43     public void buildFloor() {}
44 
45     /* abstract build the Ceiling */
46     public void buildCeiling() {}
47 
48     /* abstract build the Wall */
49     public void buildWall() {}
50 }

二、其次是構建各個組塊的類，該類的算法比較穩定，基本上不須要相應的變更。

 1 public class BuildHouse {
 2     House house;
 3 
 4     public BuildHouse(House house) {
 5         this.house = house;
 6     }
 7 
 8     /*
 9      * 這部分是具體的建立房屋的算法，該部分的算法穩定性很高，
10      * 基本上不須要作過多的變更
11      */
12     public House createHouse() {
13         house.buildFloor();
14 
15         house.buildWall();
16         house.buildWall();
17         house.buildWall();
18         house.buildWall();
19 
20         house.buildWindow();
21         house.buildWindow();
22 
23         house.buildDoor();
24 
25         house.buildCeiling();
26     }
27 }

三、最後是一個簡單的使用案例。

1 /* 一個簡單的該模式的案例 */
2 public class GameManager {
3     public static void main(String [] args) {
4         BuildHouse builder = new BuildHouse(new ClassicHouse());
5 
6         House house = builder.createHouse();
7     }
8 }

上面就是生成器模式的基本概念和基本的使用。整體上來講，生成器模式仍是比較易於理解的，這裏須要進行區別的是要將生成器模式和前一節的抽象工廠模式進行區別開來。下面稍微總結一下生成器模式：

　　一、Builder主要是「分步驟構建一個複雜對象」，構造複雜對象的算法基本上是穩定的。

　　二、Abstract Factory主要解決一系列對象的變化，而Builder主要是「對象部分」的需求變化。對於Builder來講，在最後一步返回產品，而Abstract Factory是當即返回產品的。