工厂模式——烘烤OO披萨

一、简单披萨店

我们在对象村开了家简单的披萨店，下面是披萨店制作披萨的代码：

public class PizzaStore {
	    Pizza orderPizza(String type) {
        Pizza pizza = null;
        //根据类型创建不同种类的披萨
        if (type.equals("cheese")) {
            pizza = new CheesePizza();
        }else if (type.equals("greek")) {
            pizza = new GreekPizza();
        }
		//加工披萨步骤
        pizza.prepare();

        pizza.cut();

        pizza.box();
    }
}

为什么不要使用具体实例化(WHY)

代码绑着具体类会导致代码更耦合。当使用"new"时，就是在实例化一个具体类，一旦有变化或扩展，比如增加新的类型的披萨，就必须重新打开这段代码进行检查和修改。

如何使用简单工厂替代具体实例化(HOW)

需要遵循"对扩展开放，对修改关闭”的原则解耦合，很明显地，根据类型创建不同种类的披萨是变化的部分，而加工披萨是不会改变的部分。要把前者移到另一个类中，我们称之为工厂类。一旦有了工厂SimplePizzaFactory，披萨店orderPizza()就变成客户，需要披萨的时候就叫工厂做一个，自己只需要调用prepare()、cut()、box()等加工方法。
建立一个简单的披萨工厂：

public class SimplePizzaFactory {
    //只做一件事：创建披萨
    public Pizza createPizza(String type) {
        Pizza pizza = null;
        if (type.equals("cheese")) {
            pizza = new CheesePizza();
        }else if (type.equals("greek")) {
            pizza = new GreekPizza();
        }
        return pizza;
    }
}

这样做似乎只是把问题转移到另一个类，但是工厂类可能有多个客户，譬如宅急送类、披萨店菜单类等都会调用工厂类。当以后改变时，只需要修改工厂类一处。
重构pizzaStore类：

public class PizzaStore {
    SimplePizzaFactory simplePizzaFactory;

    //PizzaStore的构造器，参数为工厂
    public PizzaStore(SimplePizzaFactory simplePizzaFactory) {
        this.simplePizzaFactory = simplePizzaFactory;
    }
    
    public Pizza orderPizza(String type) {
        Pizza pizza;
        //使用工厂类来创建披萨，取代new具体实例化的方法。
        pizza = simplePizzaFactory.createPizza(type);
        
        pizza.prepare();
        
        pizza.cut();
        
        pizza.box();
        
        return pizza;
    }
}

什么是简单工厂(WHAT)

简单工厂其实不是一个设计模式，而是一种编程习惯，它不是工厂模式(Factory Pattern)。披萨店的类图如下：

二、披萨加盟店

简单披萨店经营有成，现在大家都希望加盟，在自家附近开店，身为公司CEO，你希望把控加盟店的质量，都用你的代码。但是各地有风味差异，所以需要建立一个框架。

如何解决风味差异的问题(HOW)

有个做法可让披萨制作局限于PizzaStore类，同时加盟店又可以自由制作该区域风味。所要做的就是把createPizza()放回到PizzaStore类，不过要把它设置为“抽象方法”，然后每个加盟店创建其子类。类图及代码如下：

public abstract class PizzaStorePlus {
    public Pizza orderPizza(String type) {
        Pizza pizza;
        //createPizza()方法从工厂类中移回PizzaStore
        pizza = createPizza(type);

        pizza.prepare();

        pizza.cut();

        pizza.box();

        return pizza;
    }
    //抽象的
    abstract Pizza createPizza(String type);
}
//纽约分店
public class NYPizzaStore extends PizzaStorePlus {
    @Override
    Pizza createPizza(String type) {
        Pizza pizza = null;
        if (type.equals("cheese")) {
            pizza = new NYCheesePizza();
        }else if (type.equals("greek")) {
            pizza = new NYGreekPizza();
        }
        return pizza;
    }
}
//芝加哥分店
public class ChicagoPizzaStore extends PizzaStorePlus {
    @Override
    Pizza createPizza(String type) {
        Pizza pizza = null;
        if (type.equals("cheese")) {
            pizza = new ChicagoCheesePizza();
        }else if (type.equals("greek")) {
            pizza = new ChicagoGreekPizza();
        }
        return pizza;
    }
}

披萨同样需要定义为抽象的，以便不同风味的具体子类继承：

public abstract class Pizza {

    String name;
    //佐料
    List toppings = new ArrayList();

    void prepare() {
        System.out.println("准备烘焙：" + name);
        System.out.println("加佐料：");
        for(int i=0;i<toppings.size();i++) {
            System.out.println("   "+toppings.get(i));
        }
    }

    void cut() {
        System.out.println("切披萨");
    }

    void box() {
        System.out.println("装披萨");
    }

    public String getName() {
        return name;
    }
}

public class NYCheesePizza extends Pizza{
    public NYCheesePizza() {
        name = "纽约Cheese披萨";
        toppings.add("意大利高级奶酪");
    }
}

public class ChicagoCheesePizza extends Pizza {
    public ChicagoCheesePizza() {
        name = "芝加哥Cheese披萨";
        toppings.add("意大利白干奶酪");
    }

    void cut() {
        System.out.println("切成正方形");
    }
}

我们来订购披萨：

public class PizzaDrive {
    public static void main(String[] args) {
        NYPizzaStore nyPizzaStore = new NYPizzaStore();
        ChicagoPizzaStore chicagoPizzaStore = new ChicagoPizzaStore();
        Pizza pizza = nyPizzaStore.orderPizza("cheese");
        System.out.println("订了个："+pizza.getName());
        pizza = chicagoPizzaStore.orderPizza("cheese");
        System.out.println("订了个："+pizza.getName());
    }
}

超类不用管细节，通过实例化正确的披萨子类，子类会自行照料一切。运行结果如下：

什么是工厂方法模式(WHAT)

工厂方法模式的构成:

工厂方法模式由创建者类（PizzaStore及其子类）和产品类(Pizza及其子类)构成。工厂方法模式通过让子类决定该创建的对象是什么，来达到将对象创建的过程封装的目的。

工厂方法模式的定义:

工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。所谓的“决定”是指在编写创建者类时，不需要知道实际创建的产品是哪一个，选择使用哪个子类，自然就决定了实际创建的产品是什么。工厂方法模式类图如下：

依赖倒置原则(WHAT)

工厂方法模式其实遵循了依赖倒置原则。
如下，披萨店直接创建各种披萨对象，于是完全依赖于它们

我们需要遵循依赖倒置原则：要依赖抽象，不要依赖具体类。它是一个著名的OO设计原则。应用工厂方法模式后，高层组件（披萨店）和低层组件（各种披萨）都依赖Pizza抽象类，这就是倒置，类图如下：

依赖倒置原则的指导方针：
变量不可以持有具体类的引用。如：使用new，可以使用工厂来替代它
不要让类派生自具体类。请派生自抽象类。
不要覆盖基类已实现的方法。

三、新增原料工厂

为什么要使用抽象工厂模式(WHY)

有一些加盟店使用低价原料来增加利润，我们必须采取手段控制原料，以免损害品牌。你打算建造一家生产原料的工厂。原料包括酱料和芝士等。开始为原料工厂定义一个接口：

public interface PizzaIngredientFactory {
    public Cheese createCheese();

    public Clams createClams();
}

纽约和芝加哥的原料工厂实现它：

public class NYPizzaIngredientFactory implements PizzaIngredientFactory {
    @Override
    public Cheese createCheese() {
        return new ReggianoCheese();
    }

    @Override
    public Clams createClams() {
        return new FreshClams();
    }
}

public class ChicagoPizzaIngredientFactory implements PizzaIngredientFactory {
    @Override
    public Cheese createCheese() {
        return new ChicagoCheese();
    }

    @Override
    public Clams createClams() {
        return new ChicagoClams();
    }
}

原料改变，将prepare()方法声明为抽象方法，重构披萨：

public abstract class Pizza {

    String name;
    
    Cheese cheese;
    
    Clams clams;
    //佐料
    List toppings = new ArrayList();

    abstract void prepare();

    void cut() {
        System.out.println("切披萨");
    }

    void box() {
        System.out.println("装披萨");
    }

    public String getName() {
        return name;
    }

    public String toString() {

    }
}

我们曾经写过NYCheesePizza和ChicagoCheesePizza，它们唯一的差别在于区域性原料不同，这个让原料工厂处理差异就行，所以我们只需设计CheesePizza和ClamPizza：

public class CheesePizza extends Pizza {
    PizzaIngredientFactory factory;
    //要制作披萨，需要工厂提供原料。所以每个披萨类都需要从构造器参数得到一个工厂来制造原料。
    public CheesePizza(PizzaIngredientFactory factory) {
        this.factory = factory;
    }

    @Override
    void prepare() {
        System.out.println("Preparing " + name);

        cheese = factory.createCheese();
    }
}

public class ClamsPizza extends Pizza {
    PizzaIngredientFactory factory;
    //要制作披萨，需要工厂提供原料。所以每个披萨类都需要从构造器参数得到一个工厂来制造原料。
    public ClamsPizza(PizzaIngredientFactory factory) {
        this.factory = factory;
    }

    @Override
    void prepare() {
        System.out.println("Preparing " + name);

        clams = factory.createClams();
    }
}

加盟店需要使用对应原料工厂的披萨，我们将加盟店与当地原料工厂搭上关系：

public class NYPizzaStorePlus extends PizzaStorePlus {
    @Override
    Pizza createPizza(String type) {
        Pizza pizza = null;
        PizzaIngredientFactory ingredientFactory = new NYPizzaIngredientFactory();
        if (type.equals("cheese")) {
            pizza = new CheesePizza(ingredientFactory);
            pizza.setName("纽约起司披萨");

        }else if (type.equals("clams")) {
            pizza = new ClamsPizza(ingredientFactory);
            pizza.setName("纽约蛤蜊披萨");
        }
        return pizza;
    }
}

public class ChicagoPizzaStorePlus extends PizzaStorePlus {
    @Override
    Pizza createPizza(String type) {
        Pizza pizza = null;
        PizzaIngredientFactory ingredientFactory = new NYPizzaIngredientFactory();
        if (type.equals("cheese")) {
            pizza = new CheesePizza(ingredientFactory);
            pizza.setName("芝加哥起司披萨");

        }else if (type.equals("clams")) {
            pizza = new ClamsPizza(ingredientFactory);
            pizza.setName("芝加哥蛤蜊披萨");
        }
        return pizza;
    }
}

订购披萨：

public class PizzaDrivePlus {
    public static void main(String[] args) {
        NYPizzaStorePlus nyPizzaStorePlus = new NYPizzaStorePlus();
        ChicagoPizzaStorePlus chicagoPizzaStorePlus = new ChicagoPizzaStorePlus();
        Pizza pizza = nyPizzaStorePlus.orderPizza("cheese");
        System.out.println("订了个："+pizza.getName());
        pizza = chicagoPizzaStorePlus.orderPizza("cheese");
        System.out.println("订了个："+pizza.getName());
    }
}

结果如下：

什么是抽象工厂模式(WHAT)

抽象工厂模式提供一个抽象的接口，用于创建一组产品，而不需要知道实际产出的具体产品是什么。另外抽象工厂的方法经常以工厂方法的方式实现。类图如下：

工厂方法模式与抽象工厂模式异同(WHERE)

同：都是把应用程序从特定实现中解耦。
异：工厂方法使用继承；抽象工厂使用组合。