jQuery火箭图标返回顶部代码

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

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

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

                                                                               仅仅是指的和一般OO设计的思考方式完

                                                                               全相反（不能让高层组件依赖底层组件，

                                                                               而且，不管高层组件还是底层组件，“

                                                                               两者”都应该依赖于抽象）。

你应该还没有完全理解这个原则，现在来举个例子加深理解：

那么此时，让我们看一下对象依赖关系：

上面那个是没有使用依赖倒置原则的，下面来看使用了依赖倒置原则的：

此时此刻我们注意到，高层组件（PizzaStore）和底层组件（这些披萨）都依赖Pizza抽象，即

遵循了依赖倒置原则。现在我们解释:不能让高层组件依赖底层组件，而且，不管高层组件还是

底层组件，“两者”都应该依赖于抽象.现在PizzsStore（高层组件）和那些披萨实现类（底层

组件）都依赖于一个抽象类Pizza。

那么如何在设计中遵循依赖倒置原则嘞（下面只是一些建议，再具体项目中不一定都要遵循，

因为如果你想都遵循，可能你连一个简单的程序都写不出来了）：

              ①变量不可以持有具体类的引用（如果使用new，就会持有具体类的引用。你可以改

                 用工厂来避开这样的说法）；

              ②不要让类派生自具体类（如果派生自具体类，你就会依赖具体类。请派生一个抽象）

              ③不要覆盖基类中意实现的方法（如果覆盖基类已实现的方法，那么你的基类就不是

                  一个真正适合被继承的抽象。基类中已实现的方法，应该有所有的子类共享）。

现在让我们回到我们的披萨店

建造原料工厂：

public interface PizzaIngredientFactory {
 
    public Dough createDough();
    public Sauce createSauce();
    public Cheese createCheese();
    public Veggies[] createVeggies();
    public Pepperoni createPepperoni();
    public Clams createClam();
 
}

现在我们有不同地方的原料工厂，他们都要实现原料工厂这一个接口：

纽约原料工厂：

public class NYPizzaIngredientFactory implements PizzaIngredientFactory {
 
    public Dough createDough() {
        return new ThinCrustDough();
    }
 
    public Sauce createSauce() {
        return new MarinaraSauce();
    }
 
    public Cheese createCheese() {
        return new ReggianoCheese();
    }
 
    public Veggies[] createVeggies() {
        Veggies veggies[] = { new Garlic(), new Onion(), new Mushroom(), new RedPepper() };
        return veggies;
    }
 
    public Pepperoni createPepperoni() {
        return new SlicedPepperoni();
    }

    public Clams createClam() {
        return new FreshClams();
    }
}

还有很多，现在我们就一纽约原料工厂为例啦，其他的都是差不多的。

来看看我们的抽象类Pizza（Pizza.java）,第2-8行是披萨都持有的原料：

public abstract class Pizza {
    String name;
    Dough dough;
    Sauce sauce;
    Veggies veggies[];
    Cheese cheese;
    Pepperoni pepperoni;
    Clams clam;

    abstract void prepare();

    void bake() {
        System.out.println("Bake for 25 minutes at 350");
    }

    void cut() {
        System.out.println("Cutting the pizza into diagonal slices");
    }

    void box() {
        System.out.println("Place pizza in official PizzaStore box");
    }

    void setName(String name) {
        this.name = name;
    }

    String getName() {
        return name;
    }

    public String toString() {
        StringBuffer result = new StringBuffer();
        result.append("---- " + name + " ----
");
        if (dough != null) {
            result.append(dough);
            result.append("
");
        }
        if (sauce != null) {
            result.append(sauce);
            result.append("
");
        }
        if (cheese != null) {
            result.append(cheese);
            result.append("
");
        }
        if (veggies != null) {
            for (int i = 0; i < veggies.length; i++) {
                result.append(veggies[i]);
                if (i < veggies.length-1) {
                    result.append(", ");
                }
            }
            result.append("
");
        }
        if (clam != null) {
            result.append(clam);
            result.append("
");
        }
        if (pepperoni != null) {
            result.append(pepperoni);
            result.append("
");
        }
        return result.toString();
    }
}

开始重做一个芝士披萨（CheesePizza.java）,要做披萨，需要每个原料工厂提供原料。所以每个
披萨类都需要从构造器参数中得到一个工厂，并把这个工厂存储在一个实例变量中。在这里我们

实现了抽象类Pizza中的抽象方法prepare（）：

public class CheesePizza extends Pizza {
    PizzaIngredientFactory ingredientFactory;
 
    public CheesePizza(PizzaIngredientFactory ingredientFactory) {
        this.ingredientFactory = ingredientFactory;
    }
 
    void prepare() {
        System.out.println("Preparing " + name);
        dough = ingredientFactory.createDough();
        sauce = ingredientFactory.createSauce();
        cheese = ingredientFactory.createCheese();
    }
}

是时候回到披萨店了（纽约披萨店NYPizzaStore.java）：

public class NYPizzaStore extends PizzaStore {
 
    protected Pizza createPizza(String item) {
        Pizza pizza = null;
        PizzaIngredientFactory ingredientFactory = new NYPizzaIngredientFactory();
 
        if (item.equals("cheese")) {
  
            pizza = new CheesePizza(ingredientFactory);
            pizza.setName("New York Style Cheese Pizza");
  
        } else if (item.equals("veggie")) {
 
            pizza = new VeggiePizza(ingredientFactory);
            pizza.setName("New York Style Veggie Pizza");
 
        } else if (item.equals("clam")) {
 
            pizza = new ClamPizza(ingredientFactory);
            pizza.setName("New York Style Clam Pizza");
 
        } else if (item.equals("pepperoni")) {

            pizza = new PepperoniPizza(ingredientFactory);
            pizza.setName("New York Style Pepperoni Pizza");
 
        } 
        return pizza;
    }
}

现在添加一个测试类（Main.java）：

public class Main {
 
    public static void main(String[] args) {
 
        Pizza pizza = nyStore.orderPizza("cheese");
        System.out.println("Ethan ordered a " + pizza + "
");

        pizza = nyStore.orderPizza("clam");
        System.out.println("Ethan ordered a " + pizza + "
");

        pizza = nyStore.orderPizza("pepperoni");
        System.out.println("Ethan ordered a " + pizza + "
");

        pizza = nyStore.orderPizza("veggie");
        System.out.println("Ethan ordered a " + pizza + "
");
    }
}

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