简单工厂续 simple factory furthermore

简单工厂续 simple factory furthermore

紧接着上一篇随笔介绍Simple Factory，如果我们需要create各种各样的Pizza，我们可以在PizzaFactory里面的factoryPizzaCreation( )内
写上无数的if...else if...。当然也可以分门别类，用不同的PizzaFactory构造不同系列的Pizza，如下：

注意：因为XXFactory很多，我们用一个class family来实现它们之间的复用，考虑到调用的时候会有许多if...else if...语句来判断
具体用哪个XXFactory（来生成Pizza），所以又设计了一个FacFac类，用它的 factoryCreation方法来专门生成相应的XXFactory，
这个类相当于“工厂的工厂”。

这样，FacFac和AbstFactory的子类封装了变化的部分（前者是封装XXFactory的变化，后者封装XXPizza的变化），
其他的类都可以保持稳定。

下面是用NYFactory来生成一个NYCheesePizza的时序图：



主要实现代码如下：

 1 package  SimpleFactory;
 2
 3 public   class  PizzaStore
 4 {
 5
 6    AbstFactory mAbstFactory;
 7    Pizza mPizza;
 8    FacFac mFacfac = new FacFac(); //FacFac是专门用于生产XXPizzaFactory的Factory
 9
10
11    public Pizza createPizza(String pizzaName, String pizzaFactory)
12    {
13
14        mAbstFactory = mFacfac.factoryCreation(pizzaFactory);
15        mPizza = mAbstFactory.factoryPizzaCreation(pizzaName);
16        return mPizza;
17    }
18
19    public Pizza orderPizza()
20    {
21        mPizza.prepare();
22        mPizza.bake();
23        mPizza.cut();
24        mPizza.box();
25        return mPizza;
26    }
27}
28

package  SimpleFactory;

public   class  FacFac
{

    AbstFactory mFactory;

    public AbstFactory factoryCreation(String factoryName)
    {
        if (factoryName.equals("NYFactory"))
        {
            mFactory = new NYFactory();
            System.out.println("New York Factory demanded");
            return mFactory;
        }
        else if (factoryName.equals("ChiFactory"))
        {
            mFactory = new ChiFactory();
            System.out.println("Chicago Factory demanded");
        }
        return null;

    }
}

 1 package  SimpleFactory;
 2
 3 public   class  NYFactory  extends  AbstFactory
 4 {
 5
 6    Pizza mPizza;
 7
 8    @Override
 9    public Pizza factoryPizzaCreation(String pizzaName)
10    {
11        if (pizzaName.equals("NYCheesePizza"))
12        {
13            mPizza = new NYCheesePizza();
14            System.out.println("NYCheesePizza created");
15            return mPizza;
16        }
17        else if (pizzaName.equals("NYClamPizza"))
18        {
19            mPizza = new NYClamPizza();
20            System.out.println("NYClamPizza created");
21            return mPizza;
22        }
23        return null;
24    }
25}
26

 1 package  SimpleFactory;
 2
 3 public   class  Pizza
 4 {
 5
 6    public void prepare()
 7    {
 8        System.out.println("Pizza prepared");
 9    }
10
11    public void bake()
12    {
13        System.out.println("Pizza baked");
14    }
15
16    public void cut()
17    {
18        System.out.println("Pizza cut");
19    }
20
21    public void box()
22    {
23        System.out.println("Pizza boxed.");
24    }
25}
26

 1 package  SimpleFactory;
 2
 3 public   class  Main
 4 {
 5
 6    public static void main(String[] args)
 7    {
 8        PizzaStore store = new PizzaStore();
 9        store.createPizza("NYClamPizza", "NYFactory");
10        store.orderPizza();
11    }
12}
13

这个程序，实际上是对简单工厂思维方式的反复使用。该程序中，设计了两块容易产生变化的部分（XXFactory和XXPizza的变化）。
我们对每一部分都使用了简单工厂的思维——即把变化的部分抽象出来，用一个“工厂类”中的XXCreation方法来单独实现这段维护时
容易产生变化的代码。

在简单工厂中，每抽象一次变化的部分，就在需要保持稳定的类和新增的控制变化的类之间产生了一个Association。