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

为了面向接口编程，而不是面向实现编程，所以此时我么就不能再直接使用new了，因

为当看到“new”时，我们就会想到“具体”。

下面来看一个例子，假如你有一个披萨店，你的代码可能这么写：

    Pizza orderPizza(){
        Pizza pizza = new Pizza();
        
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        
        return pizza;
    }

但是此时你需要更多披萨类型，所以你就要修改代码，如下所示：

    Pizza orderPizza(String type){
        Pizza pizza = new Pizza();

        if (type.equals("cheese")) {
            pizza = new CheesePizza();
        } else if (type.equals("pepperoni")) {
            pizza = new PepperoniPizza();
        } else if (type.equals("clam")) {
            pizza = new ClamPizza();
        } else if (type.equals("veggie")) {
            pizza = new VeggiePizza();
        }

        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();

        return pizza;
    }

但是此时由于产业竞争问题，你想加入一些其他口味的pizza或者删除某几种pizza，那么

你就不得不修改orderPizza(String type)里的4-12行，所以随着时间的推移，这个类就必

须一改再改，这毫无疑问是不好的！所以我们现在来把创建对象的代码封装起来，如下所

示：

 

这时我们称这个新对象（SimplePizzaFactory）为“工厂”，用来处理创建对象的细节。

现在让我们创建一个简单的披萨工厂：

先从工厂本身开始，封装创建对象的代码（SimplePizzaFactory.java）：

 

public class SimplePizzaFactory {
    public Pizza createPizza(String type) {
        Pizza pizza = null;

        if (type.equals("cheese")) {
            pizza = new CheesePizza();
        } else if (type.equals("pepperoni")) {
            pizza = new PepperoniPizza();
        } else if (type.equals("clam")) {
            pizza = new ClamPizza();
        } else if (type.equals("veggie")) {
            pizza = new VeggiePizza();
        }
        return pizza;
    }
}

 

重做PizzaStore（PizzaStore.java）:

public class PizzaStore {
    SimplePizzaFactory factory;

    public PizzaStore(SimplePizzaFactory factory) {
        this.factory = factory;
    }

    public Pizza orderPizza(String type) {
        Pizza pizza;

        pizza = factory.createPizza(type);

        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();

        return pizza;
    }
}

测试类（Main.java）:

public class Main {

    public static void main(String[] args) {
        SimplePizzaFactory factory = new SimplePizzaFactory();
        PizzaStore store = new PizzaStore(factory);

        Pizza pizza = store.orderPizza("cheese");
        System.out.println("We ordered a " + pizza.getName() + "\n");
        System.out.println(pizza);

        pizza = store.orderPizza("veggie");
        System.out.println("We ordered a " + pizza.getName() + "\n");
        System.out.println(pizza);
    }
}

结果展示：

好啦，这个示例完成了，这个其实叫做简单工厂，他其实不是一个设计模式，而更像是一

种编程习惯。这里只列举了这个项目的关键代码，至于这个简单工厂的完整代码，读者可

到：https://github.com/Stray-Kite/Design-Pattern/tree/master/src/headfirst/designpatterns/factory/pizzas

下载。

 

好了，下载聊完了简单工厂，那么让我们进入正题，聊一聊两个重量级的模式，他们都是

工厂！

 

现在我们要建立几个加盟店。

有了这个图，你开始有一个想法啦，那就是：

 

NYPizzaFactory nyFactory = new NYPizzaFactory()；
PizzaStore nyStore = new PizzaStore(nyFactory)；
nyStore.orderPizza("Veggie");

ChicagePizzaFactory chicageFactory = new ChicagePizzaFactory()；
PizzaStore chicageStore = new PizzaStore(chicagoFactory)；
chicagoStore.orderPizza("Veggie");

 

但是，你想要多一些质量控制：在推广SimpleFactory时，你发现加盟店的确是采用你的工

厂创建披萨，但是其他部分，却开始采用他们自创的流程：烘烤的做法有些差异、不要切片

、使用其他厂商的盒子。

再想想这个问题，你真的希望能够建立一个框架，把加盟店和创建披萨捆绑在一起的同时又

保持一定的弹性。

 

所以开始使用框架啦：

首先，看看PizzaStore（PizzaStore.java）所做的改变；喔嚯，变成抽象的了，也就是把创

建对象的工作移交给子类做决定了：

public abstract class PizzaStore {
    abstract Pizza createPizza(String item);

    public Pizza orderPizza(String type) {
        Pizza pizza = createPizza(type);
        System.out.println("--- Making a " + pizza.getName() + " ---");
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}

接下来，轮到子类给PizzaStore做决定了！（NYPizzaStore.java和ChicagePizzaStore.java

，这是两个披萨店）：

public class ChicagoPizzaStore extends PizzaStore {
    Pizza createPizza(String item) {
        if (item.equals("cheese")) {
            return new ChicagoStyleCheesePizza();
        } else if (item.equals("veggie")) {
            return new ChicagoStyleVeggiePizza();
        } else if (item.equals("clam")) {
            return new ChicagoStyleClamPizza();
        } else if (item.equals("pepperoni")) {
            return new ChicagoStylePepperoniPizza();
        } else return null;
    }
}

public class NYPizzaStore extends PizzaStore{
    Pizza createPizza(String item) {
        if (item.equals("cheese")) {
            return new NYStyleCheesePizza();
        } else if (item.equals("veggie")) {
            return new NYStyleVeggiePizza();
        } else if (item.equals("clam")) {
            return new NYStyleClamPizza();
        } else if (item.equals("pepperoni")) {
            return new NYStylePepperoniPizza();
        } else return null;
    }
}

差点忘记了，我们还得写一个比萨本身(Pizza.java)：

import java.util.ArrayList;

public abstract class Pizza {
    String name;
    String dough;
    String sauce;
    ArrayList<String> toppings = new ArrayList<String>();

    void prepare() {
        System.out.println("Prepare " + name);
        System.out.println("Tossing dough...");
        System.out.println("Adding sauce...");
        System.out.println("Adding toppings: ");
        for (String topping : toppings) {
            System.out.println("   " + topping);
        }
    }

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

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

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

    public String getName() {
        return name;
    }

    public String toString() {
        StringBuffer display = new StringBuffer();
        display.append("---- " + name + " ----\n");
        display.append(dough + "\n");
        display.append(sauce + "\n");
        for (String topping : toppings) {
            display.append(topping + "\n");
        }
        return display.toString();
    }
}

然后还剩下，一些具体的子类：定义两个不同的店的芝士披萨

NYStyleCheesePizza.java:

public class NYStyleCheesePizza extends Pizza {
    public NYStyleCheesePizza() {
        name = "NY Style Sauce and Cheese Pizza";
        dough = "Thin Crust Dough";
        sauce = "Marinara Sauce";

        toppings.add("Grated Reggiano Cheese");
    }
}

ChicagoStyleCheesePizza.java:

public class ChicagoStyleCheesePizza extends Pizza {
    public ChicagoStyleCheesePizza() {
        name = "Chicago Style Deep Dish Cheese Pizza";
        dough = "Extra Thick Crust Dough";
        sauce = "Plum Tomato Sauce";

        toppings.add("Shredded Mozzarella Cheese");
    }

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

 

最后来一组测试类（Main.java）：

public class Main {

    public static void main(String[] args) {
        PizzaStore nyStore = new NYPizzaStore();
        PizzaStore chicagoStore = new ChicagoPizzaStore();

        Pizza pizza = nyStore.orderPizza("cheese");
        System.out.println("Ethan ordered a " + pizza.getName() + "\n");

        pizza = chicagoStore.orderPizza("cheese");
        System.out.println("Joel ordered a " + pizza.getName() + "\n");

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

        pizza = chicagoStore.orderPizza("clam");
        System.out.println("Joel ordered a " + pizza.getName() + "\n");

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

        pizza = chicagoStore.orderPizza("pepperoni");
        System.out.println("Joel ordered a " + pizza.getName() + "\n");

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

        pizza = chicagoStore.orderPizza("veggie");
        System.out.println("Joel ordered a " + pizza.getName() + "\n");
    }
}

 

结果展示（部分结果）：

 

此段代码地址：

          https://github.com/Stray-Kite/Design-Pattern/tree/master/src/headfirst/designpatterns/factory/pizzafm

好了，现在然我们看一下工厂模式的定义吧！

工厂模式：定义一个创建对象的接口，但由子类决定要实例化的是哪一个。工厂方法让类把

实例化推迟到了子类。

重点：简单工厂和工厂方法的区别：

                 子类的确看起来很像简单工厂。简单工程把全部的事情，在一个地方都处理完了，然而工厂方

          法却是创建了一个框架，让子类决定要如何实现。比方说，在工厂方法中，orderPizza()方法提供了

          一个一般的框架，以便创建披萨，orderPizza()方法依赖工厂方法创建具体类，并制造出实际的披萨

          。可通过继承PizzaStore()类，决定实际制造出的披萨是什么。简单工厂的做法，可以将对象创建封

          装起来，但是简单工厂不具备工厂方法的弹性，因为简单工程不能变更正在创建的产品。

未完待续......