设计模式之工厂模式（下篇）

今天我们来讲一讲抽象工厂：

重要涉及原则：要依赖抽象，不要依赖具体。

首先我们需要了解一个设计原则——依赖倒置原则：减少对具体的依赖，所谓的倒置是倒置的

                                                                               仅仅是指的和一般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 }

一切完成，现在让我们看一下这个项目的类图，有一点儿复杂，请静下心来看：