趣解设计模式之《小王的披萨店》

〇、小故事

小王看到最近越来越多的人喜欢吃披萨了，所以，他决定自己也开一个披萨店。最初开的时候，他只提供了一种口味的披萨，因为这样先试试水，看看生意如何，如果生意不好，也可以快速止损。

没想到由于小王手艺不错，天生就有制作披萨的天赋，生意异常的火爆。于是他决定再多增加几种口味的披萨。那么，之前的版本，是将制作披萨和售卖披萨放在一套逻辑处理的，但是此时如果多增加几种口味，只应该影响制作披萨这部分，而不应该牵涉到影响售卖披萨这部分的。那么如何处理呢？我们来看一下今天要介绍的模式——工厂方法模式。

一、解决方法1：简单工厂

1.1> 解决思路

我们创建对象的时候，会在业务代码里直接new对象。比如，我们的披萨商店需要创建披萨，那么会在orderPizza方法中，通过pizzaType这个属性，写一堆if...else的语句，来创建不同的披萨对象。那么，随着披萨类型越来越多，PizzaStore类就会越来越大。

而PizzaStore类包含的是Pizza对象类型的生成和Pizza的制作行为这两部分。而Pizza的制作过程很少变化，所以，将Pizza的对象生成判断逻辑拿出来，放到SimplePizzaFactory类，那么，PizzaStore类就相对稳定了。不会因为增加Pizza类型，伴随着有可能会“误伤”pizza制作的逻辑代码了（比如，误删了pizza制作的相关代码部分）。

1.2> 定义

简单工厂（Simple Factory）

简单工厂其实不是一个设计模式，反而比较像是一种编程习惯。

1.3> 类图

1.4> 代码实现

披萨类接口：Pizza.java

public interface Pizza {
    void prepare();
    void bake();
    void cut();
    void box();
}

奶酪披萨：CheesePizza.java

public class CheesePizza implements Pizza {
    public void prepare() {
        System.out.println("CheesePizza prepare()");
    }
    public void bake() {
        System.out.println("CheesePizza bake()");
    }
    public void cut() {
        System.out.println("CheesePizza cut()");
    }
    public void box() {
        System.out.println("CheesePizza box()");
    }
}

蛤蜊披萨：ClamPizza.java

public class ClamPizza implements Pizza {
    public void prepare() {
        System.out.println("ClamPizza prepare()");
    }
    public void bake() {
        System.out.println("ClamPizza bake()");
    }
    public void cut() {
        System.out.println("ClamPizza cut()");
    }
    public void box() {
        System.out.println("ClamPizza box()");
    }
}

意大利辣香肠披萨：PepperoniPizza.java

public class PepperoniPizza implements Pizza {
    public void prepare() {
        System.out.println("PepperoniPizza prepare()");
    }
    public void bake() {
        System.out.println("PepperoniPizza bake()");
    }
    public void cut() {
        System.out.println("PepperoniPizza cut()");
    }
    public void box() {
        System.out.println("PepperoniPizza box()");
    }
}

素食披萨：VeggiePizza.java

public class VeggiePizza implements Pizza {
    public void prepare() {
        System.out.println("VeggiePizza prepare()");
    }
    public void bake() {
        System.out.println("VeggiePizza bake()");
    }
    public void cut() {
        System.out.println("VeggiePizza cut()");
    }
    public void box() {
        System.out.println("VeggiePizza box()");
    }
}

简单披萨工厂类：SimplePizzaFactory.java

public class SimplePizzaFactory {
    public Pizza createPizza(String pizzaType) {
        Pizza pizza = null;
        if (pizzaType.equals("cheese")) {
            pizza = new CheesePizza();
        } else if (pizzaType.equals("pepperoni")) {
            pizza = new PepperoniPizza();
        } else if (pizzaType.equals("clam")) {
            pizza = new ClamPizza();
        } else if (pizzaType.equals("veggie")) {
            pizza = new VeggiePizza();
        }
        return pizza;
    }
}

披萨店类：PizzaStoreV1.java

public class PizzaStoreV1 {
    private SimplePizzaFactory factory;
    public PizzaStoreV1(SimplePizzaFactory factory) {
        this.factory = factory;
    }
    Pizza orderPizza(String pizzaType) {
        Pizza pizza = factory.createPizza(pizzaType);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}

测试类：PizzaStoreTest.java

public class PizzaStoreTest {
    public static void main(String[] args) {
        pizzaStoreV1Test();
    }
    
    /** 简单工厂 */
    private static void pizzaStoreV1Test() {
        PizzaStoreV1 pizzaStoreV1 = new PizzaStoreV1(new SimplePizzaFactory());
        pizzaStoreV1.orderPizza("cheese");
    }
}

执行结果：

CheesePizza prepare()
CheesePizza bake()
CheesePizza cut()
CheesePizza box()

二、解决方法2：工厂方法模式

2.1> 简单工厂的缺陷

如果采用简单工厂，每次需要创建新的对象的时候，都需要修改简单工厂类SimplePizzaFactory中创建对象的方法。为了解决这个问题，我们引入了工厂方法模式，即：如果有新的地区要开披萨店，那么即使是同样的pizzaType，但是不同地区的口味依然是不同的，那么我们可以通过新建一个PizzaStore的子类来实现不同地区制作披萨的行为，而不需要频繁的修改SimplePizzaFactory类了，满足了开闭原则。

2.2> 模式定义

工厂方法模式（Factory Method Pattern）

定义了一个创建对象的接口（类或接口中的方法），但由子类决定要实例化的类是哪一个。工厂方法把实例化推迟到子类。

当需要创建多种复杂类型的对象时，可以考虑使用工厂方法对对象进行归类。

2.3> 类图

我们将披萨工厂进行抽象PizzaStore，由子类NYPizzaStore和ChicagoPizzaStore来实现createPizza()方法，该方法就是工厂方法，用来创建披萨类Pizaa。

2.4> 代码实现

纽约口味的披萨：NYCheesePizza、NYClamPizza、NYPepperoniPizza、NYVeggiePizza

/** 纽约口味——奶酪披萨 **/
public class NYCheesePizza implements Pizza {
    public void prepare() {
        System.out.println("NYCheesePizza prepare()");
    }

    public void bake() {
        System.out.println("NYCheesePizza bake()");
    }

    public void cut() {
        System.out.println("NYCheesePizza cut()");
    }

    public void box() {
        System.out.println("NYCheesePizza box()");
    }
}

/** 纽约口味——牡蛎披萨 **/
public class NYClamPizza implements Pizza {
    public void prepare() {
        System.out.println("NYClamPizza prepare()");
    }

    public void bake() {
        System.out.println("NYClamPizza bake()");
    }

    public void cut() {
        System.out.println("NYClamPizza cut()");
    }

    public void box() {
        System.out.println("NYClamPizza box()");
    }
}

/** 纽约口味——意大利辣香肠披萨 **/
public class NYPepperoniPizza implements Pizza {
    public void prepare() {
        System.out.println("NYPepperoniPizza prepare()");
    }

    public void bake() {
        System.out.println("NYPepperoniPizza bake()");
    }

    public void cut() {
        System.out.println("NYPepperoniPizza cut()");
    }

    public void box() {
        System.out.println("NYPepperoniPizza box()");
    }
}

/** 纽约口味——素食披萨 **/
public class NYVeggiePizza implements Pizza {
    public void prepare() {
        System.out.println("NYVeggiePizza prepare()");
    }

    public void bake() {
        System.out.println("NYVeggiePizza bake()");
    }

    public void cut() {
        System.out.println("NYVeggiePizza cut()");
    }

    public void box() {
        System.out.println("NYVeggiePizza box()");
    }
}

芝加哥口味的披萨：ChicagoCheesePizza、ChicagoClamPizza、ChicagoPepperoniPizza、ChicagoVeggiePizza

/** 芝加哥口味——奶酪披萨 **/
public class ChicagoCheesePizza implements Pizza {

    public void prepare() {
        System.out.println("ChicagoCheesePizza prepare()");
    }

    public void bake() {
        System.out.println("ChicagoCheesePizza bake()");
    }

    public void cut() {
        System.out.println("ChicagoCheesePizza cut()");
    }

    public void box() {
        System.out.println("ChicagoCheesePizza box()");
    }
}

/** 芝加哥口味——牡蛎披萨 **/
public class ChicagoClamPizza implements Pizza {

    public void prepare() {
        System.out.println("ChicagoClamPizza prepare()");
    }

    public void bake() {
        System.out.println("ChicagoClamPizza bake()");
    }

    public void cut() {
        System.out.println("ChicagoClamPizza cut()");
    }

    public void box() {
        System.out.println("ChicagoClamPizza box()");
    }
}

/** 芝加哥口味——意大利辣香肠披萨 **/
public class ChicagoPepperoniPizza implements Pizza {

    public void prepare() {
        System.out.println("ChicagoPepperoniPizza prepare()");
    }

    public void bake() {
        System.out.println("ChicagoPepperoniPizza bake()");
    }

    public void cut() {
        System.out.println("ChicagoPepperoniPizza cut()");
    }

    public void box() {
        System.out.println("ChicagoPepperoniPizza box()");
    }
}

/** 芝加哥口味——素食披萨 **/
public class ChicagoVeggiePizza implements Pizza {

    public void prepare() {
        System.out.println("ChicagoVeggiePizza prepare()");
    }

    public void bake() {
        System.out.println("ChicagoVeggiePizza bake()");
    }

    public void cut() {
        System.out.println("ChicagoVeggiePizza cut()");
    }

    public void box() {
        System.out.println("ChicagoVeggiePizza box()");
    }
}

披萨店抽象类：PizzaStoreV2.java

public abstract class PizzaStoreV2 {
    /** 抽象方法，需要子类实现具体行为 */
    protected abstract Pizza createPizza(String pizzaType);
    
    public Pizza orderPizza(String pizzaType) {
        Pizza pizza = createPizza(pizzaType);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}

纽约披萨店：NYPizzaStore.java

public class NYPizzaStore extends PizzaStoreV2 {
    protected Pizza createPizza(String pizzaType) {
        Pizza pizza = null;
        if (pizzaType.equals("cheese")) {
            pizza = new NYCheesePizza();
        } else if (pizzaType.equals("pepperoni")) {
            pizza = new NYPepperoniPizza();
        } else if (pizzaType.equals("clam")) {
            pizza = new NYClamPizza();
        } else if (pizzaType.equals("veggie")) {
            pizza = new NYVeggiePizza();
        }
        return pizza;
    }
}

芝加哥披萨店：ChicagoPizzaStore.java

public class ChicagoPizzaStore extends PizzaStoreV2 {
    protected Pizza createPizza(String pizzaType) {
        Pizza pizza = null;
        if (pizzaType.equals("cheese")) {
            pizza = new ChicagoCheesePizza();
        } else if (pizzaType.equals("pepperoni")) {
            pizza = new ChicagoPepperoniPizza();
        } else if (pizzaType.equals("clam")) {
            pizza = new ChicagoClamPizza();
        } else if (pizzaType.equals("veggie")) {
            pizza = new ChicagoVeggiePizza();
        }
        return pizza;
    }
}

测试类：PizzaStoreTest.java

public class PizzaStoreTest {
    public static void main(String[] args) {
        pizzaStoreV2Test();
    }

    /** 工厂方法 */
    private static void pizzaStoreV2Test() {
        PizzaStoreV2 pizzaStore = new NYPizzaStore(); // 选择纽约地区的披萨店
        pizzaStore.orderPizza("cheese");
    }
}

今天的文章内容就这些了：