設計模式之工廠模式（下篇）

今天我們來講一講抽象工廠：

重要涉及原則：要依賴抽象，不要依賴具體。

首先我們需要瞭解一個設計原則——依賴倒置原則：減少對具體的依賴，所謂的倒置是倒置的

                                                                               僅僅是指的和一般OO設計的思考方式完

                                                                               全相反（不能讓高層組件依賴底層組件，

                                                                               而且，不管高層組件還是底層組件，“

                                                                               兩者”都應該依賴於抽象）。

你應該還沒有完全理解這個原則，現在來舉個例子加深理解：

那麼此時，讓我們看一下對象依賴關係：

上面那個是沒有使用依賴倒置原則的，下麵來看使用了依賴倒置原則的：

此時此刻我們註意到，高層組件（PizzaStore）和底層組件（這些披薩）都依賴Pizza抽象，即

遵循了依賴倒置原則。現在我們解釋:不能讓高層組件依賴底層組件，而且，不管高層組件還是

底層組件，“兩者”都應該依賴於抽象.現在PizzsStore（高層組件）和那些披薩實現類（底層

組件）都依賴於一個抽象類Pizza。

那麼如何在設計中遵循依賴倒置原則嘞（下麵只是一些建議，再具體項目中不一定都要遵循，

因為如果你想都遵循，可能你連一個簡單的程式都寫不出來了）：

              ①變數不可以持有具體類的引用（如果使用new，就會持有具體類的引用。你可以改

                 用工廠來避開這樣的說法）；

              ②不要讓類派生自具體類（如果派生自具體類，你就會依賴具體類。請派生一個抽象）

              ③不要覆蓋基類中意實現的方法（如果覆蓋基類已實現的方法，那麼你的基類就不是

                  一個真正適合被繼承的抽象。基類中已實現的方法，應該有所有的子類共用）。

現在讓我們回到我們的披薩店

建造原料工廠：

 1 public interface PizzaIngredientFactory {
 2  
 3     public Dough createDough();
 4     public Sauce createSauce();
 5     public Cheese createCheese();
 6     public Veggies[] createVeggies();
 7     public Pepperoni createPepperoni();
 8     public Clams createClam();
 9  
10 }

現在我們有不同地方的原料工廠，他們都要實現原料工廠這一個介面：

紐約原料工廠：

 1 public class NYPizzaIngredientFactory implements PizzaIngredientFactory {
 2  
 3     public Dough createDough() {
 4         return new ThinCrustDough();
 5     }
 6  
 7     public Sauce createSauce() {
 8         return new MarinaraSauce();
 9     }
10  
11     public Cheese createCheese() {
12         return new ReggianoCheese();
13     }
14  
15     public Veggies[] createVeggies() {
16         Veggies veggies[] = { new Garlic(), new Onion(), new Mushroom(), new RedPepper() };
17         return veggies;
18     }
19  
20     public Pepperoni createPepperoni() {
21         return new SlicedPepperoni();
22     }
23 
24     public Clams createClam() {
25         return new FreshClams();
26     }
27 }

還有很多，現在我們就一紐約原料工廠為例啦，其他的都是差不多的。

來看看我們的抽象類Pizza（Pizza.java）,第2-8行是披薩都持有的原料：

 1 public abstract class Pizza {
 2     String name;
 3     Dough dough;
 4     Sauce sauce;
 5     Veggies veggies[];
 6     Cheese cheese;
 7     Pepperoni pepperoni;
 8     Clams clam;
 9 
10     abstract void prepare();
11 
12     void bake() {
13         System.out.println("Bake for 25 minutes at 350");
14     }
15 
16     void cut() {
17         System.out.println("Cutting the pizza into diagonal slices");
18     }
19 
20     void box() {
21         System.out.println("Place pizza in official PizzaStore box");
22     }
23 
24     void setName(String name) {
25         this.name = name;
26     }
27 
28     String getName() {
29         return name;
30     }
31 
32     public String toString() {
33         StringBuffer result = new StringBuffer();
34         result.append("---- " + name + " ----\n");
35         if (dough != null) {
36             result.append(dough);
37             result.append("\n");
38         }
39         if (sauce != null) {
40             result.append(sauce);
41             result.append("\n");
42         }
43         if (cheese != null) {
44             result.append(cheese);
45             result.append("\n");
46         }
47         if (veggies != null) {
48             for (int i = 0; i < veggies.length; i++) {
49                 result.append(veggies[i]);
50                 if (i < veggies.length-1) {
51                     result.append(", ");
52                 }
53             }
54             result.append("\n");
55         }
56         if (clam != null) {
57             result.append(clam);
58             result.append("\n");
59         }
60         if (pepperoni != null) {
61             result.append(pepperoni);
62             result.append("\n");
63         }
64         return result.toString();
65     }
66 }

開始重做一個芝士披薩（CheesePizza.java）,要做披薩，需要每個原料工廠提供原料。所以每個
披薩類都需要從構造器參數中得到一個工廠，並把這個工廠存儲在一個實例變數中。在這裡我們

實現了抽象類Pizza中的抽象方法prepare（）：

 1 public class CheesePizza extends Pizza {
 2     PizzaIngredientFactory ingredientFactory;
 3  
 4     public CheesePizza(PizzaIngredientFactory ingredientFactory) {
 5         this.ingredientFactory = ingredientFactory;
 6     }
 7  
 8     void prepare() {
 9         System.out.println("Preparing " + name);
10         dough = ingredientFactory.createDough();
11         sauce = ingredientFactory.createSauce();
12         cheese = ingredientFactory.createCheese();
13     }
14 }

是時候回到披薩店了（紐約披薩店NYPizzaStore.java）：

 1 public class NYPizzaStore extends PizzaStore {
 2  
 3     protected Pizza createPizza(String item) {
 4         Pizza pizza = null;
 5         PizzaIngredientFactory ingredientFactory = new NYPizzaIngredientFactory();
 6  
 7         if (item.equals("cheese")) {
 8   
 9             pizza = new CheesePizza(ingredientFactory);
10             pizza.setName("New York Style Cheese Pizza");
11   
12         } else if (item.equals("veggie")) {
13  
14             pizza = new VeggiePizza(ingredientFactory);
15             pizza.setName("New York Style Veggie Pizza");
16  
17         } else if (item.equals("clam")) {
18  
19             pizza = new ClamPizza(ingredientFactory);
20             pizza.setName("New York Style Clam Pizza");
21  
22         } else if (item.equals("pepperoni")) {
23 
24             pizza = new PepperoniPizza(ingredientFactory);
25             pizza.setName("New York Style Pepperoni Pizza");
26  
27         } 
28         return pizza;
29     }
30 }

現在添加一個測試類（Main.java）：

 1 public class Main {
 2  
 3     public static void main(String[] args) {
 4  
 5         Pizza pizza = nyStore.orderPizza("cheese");
 6         System.out.println("Ethan ordered a " + pizza + "\n");
 7 
 8         pizza = nyStore.orderPizza("clam");
 9         System.out.println("Ethan ordered a " + pizza + "\n");
10 
11         pizza = nyStore.orderPizza("pepperoni");
12         System.out.println("Ethan ordered a " + pizza + "\n");
13 
14         pizza = nyStore.orderPizza("veggie");
15         System.out.println("Ethan ordered a " + pizza + "\n");
16     }
17 }

一切完成，現在讓我們看一下這個項目的類圖，有一點兒複雜，請靜下心來看：