一 工厂方法模式#

我们用做披萨来比喻。工厂方法模式由creator，product两个大类组成，分别代表pizzaStore和pizza。通过一个orderPizza方法和一个工厂方法联合起来，就可以形成一个框架。工厂方法将生产知识封装进各个创建者。

1、具体的店##

---

以创建纽约风味披萨子类为例

• 实现继承自PizzaStore抽象类的具体子类，为纽约风味的披萨（NYStylePizzaStore）
• 具体子类实现createPizza方法，负责返回一个Pizza对象，由子类全权负责产生哪个具体pizza
• 继承自超类的orderpizza方法并不知道这个pizza是由哪个子类产生的，但是它知道pizza可以被烘焙，切片等等公共操作。

同样的，其他风味的披萨具体子类，也是如此创建

2、申明一个工厂方法##

---

申明工厂方法，并将这个方法传入orderpizza方法中。

protected abstract Pizza CreatePizza（String type）
orederPizza（）{
Pizza pizza;
pizza = createPizza;
...
}

工厂方法普遍公式：abstract Product factoryMethod(String type)。

3、如何点披萨呢？##

---

创建一个你要的风味的披萨店，调用orderPizza方法，传入你相关的配料参数（配置）就好了。
orderPizza不知道处理的是什么披萨，但是它就是进行统一的切片装盘。

披萨

PizzaStore nyPizzaStore = new NYPIzzaStore();
nyPizzaStore.orderPizza("cheese");
//在orderPizza中久调用了createPizza方法
Pizza pizza = createPizza("cheese");

披萨店部分完成，披萨本身呢？

4、pizza抽象类##

pizza本身，把先前公共的cut（），bake（）等等公共方法封装起来。并且可以由子类进行覆盖

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

工厂模式实现了依赖倒转。倒转了，披萨店对具体披萨的依赖，而使具体披萨店和具体披萨都依赖于一个披萨的抽象。

二 原料工厂#

每个具体店生产相同的披萨，都需要面团，酱料，芝士等等。但是具体的配料可能是不同的。

1、创建芝加哥原料工厂##

public class ChicagoIndgredientFactory implements PizzaIngredientFactory{
  public Dough createDough(){
    return new ThickCrustDough;
}
  public Sauce createSauce(){
    return new TomatoSauce;
}
...
}

2、 重做披萨

将原料变量加入抽象类pizza中，并把prepare方法申明为抽象，在具体类中，通过构造方法传入一个披萨原料工厂的抽象。在prepare方法中，通过这个披萨工厂的抽象 ，获得相应的原料，而他根本不关心这些原料来自哪里，这是由披萨店决定的。
这里可以很自然地看出，pizza中传入一个抽象原料工厂，是为了解耦，在具体的披萨店类当中，一定传入的是一个具体的原料工厂对象，从而实现依赖反转。

3、如何实现#

//首先我们需要一个纽约披萨店
PizzaStore nyPizzaStore = new NYPizzaStore;
//接受订单
nyPizzaStore.orderPizza("cheese");
//orderPizza方法首先调用createPizza方法
Pizza pizza = createPizza("cheese");
//当createPizza方法被调用，就开始涉及到原料工厂
Pizza pizza = new CheesePizza(nyIndgredientFactory);
//接下来准备披萨，调用prepare方法对原料进行加工
void prepare(){
  dough = factory.createDough();
...
}
//最后orderPizza方法进行最后的烘烤，切片，装盘

而这一切就是抽象工厂模式，工厂方法模式是抽象工厂模式的一个特殊情况。