设计模式之工厂模式（下篇）
今天我们来讲一讲抽象工厂：
重要涉及原则：要依赖抽象，不要依赖具体。
首先我们需要了解一个设计原则——依赖倒置原则：减少对具体的依赖，所谓的倒置是倒置的
仅仅是指的和一般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 }
一切完成，现在让我们看一下这个项目的类图，有一点儿复杂，请静下心来看：