设计模式之简单工厂(披萨案例)

首先看下面代码：

Duck duck = new MallardDuck();

分析：我们采用new来实例化具体类，用的是实现，而非接口，代码捆绑具体类导致代码脆弱，缺乏弹性。

倘若Duck种类变多时:

Duck duck;

if(picnic){
    duck = new MallardDuck();
}else if(hunting){
    duck = new DecoyDuck();
}else if(inBathTub){
    duck = new RubberDuck();
}

分析：我们发现，一旦有变化或扩展，就必须重新打开这段代码进行检查和修改，通常这样修改过的代码将造成部分系统更难维护和更新，而且也更容易犯错误。

基于上述分析：我们要做到：“对扩展开放，对修改关闭”！

我们发现，披萨的准备，烘烤，切片，装盒对于所有类型的披萨都是不变的，而披萨种类的选择则是变化的部分，弄清了变化与不变化的部分，我们就要使用变化分离原则了，即我们要对变化的部分实现封装，将不变化的部分放入基类中让子类继承即可。

变化的部分所在的类（披萨生产种类选择），我们称为（比萨生产的）工厂。
不变化的部分，我们称为客户。

工厂如下：(java实现)

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

重做PizzaStore类如下：（java实现）

public class PizzaStore{
    SimplePizzaFactory factory;
public PizzaStore(SimplePizzaFactory factory){
    this.factory = factory;
}
public Pizza orderPizza(String type){
    Pizza pizza;
    pizza = factory.creatPizza(type);
    pizza.prepare();
    pizza.bake();
    pizza.cut();
    pizza.box();
    return pizza;
 }
}

简单工厂其实并不是一个设计模式，反而比较像是一种编程习惯，它并没有引出什么新的设计原则，依然是在我们之前所说的变化分离原则，针对接口而不针对实现编程原则，少用继承多用组合原则，低耦合性的条件下来实现的，基于如此，我们就不多说了，类图也就不写了，直接上代码，类图实现过程等大家自行脑补吧，哈哈，接下来的博文我将继续写更加高深的工厂模式以及新的设计原则，请大家关注。

下面为披萨案例的C++实现：

#include<iostream>
using namespace std;
class Pizza
{
private:
    string m_type;
public:
    Pizza(string _m_type):m_type(_m_type) {}
    virtual ~Pizza() {}
    virtual void prepare()
    {
        cout<<"prepare "<<m_type<<endl;
    }
    virtual void bake()
    {
        cout<<"bake "<<m_type<<endl;
    }
    virtual void cut()
    {
        cout<<"cut "<<m_type<<endl;
    }
    virtual void box()
    {
        cout<<"box "<<m_type<<endl;
    }
};
class ChiChagoCheesePizza:public Pizza
{
public:
    ChiChagoCheesePizza():Pizza("chichago cheese") {}
    ~ChiChagoCheesePizza() {}
};
class ChiChagoGreekPizza : public Pizza
{
public:
    ChiChagoGreekPizza() : Pizza("chichago greek") {}
    ~ChiChagoGreekPizza() {}
};
class NYCheesePizza : public Pizza
{
public:
    NYCheesePizza() : Pizza("ny cheese") {}
    ~NYCheesePizza() {}
};
class NYGreekPizza : public Pizza
{
public:
    NYGreekPizza() : Pizza("ny greek") {}
    ~NYGreekPizza() {}
};
class SimplePizzaFactory
{
public:
    virtual Pizza *CreatePizza(const std::string &type) = 0;
};
class ChiChagoPizzaFactory : public SimplePizzaFactory
{
public:
    Pizza *CreatePizza(const std::string &type)
    {
        if ( "cheese" == type )
        {
            return new ChiChagoCheesePizza();
        }
        if ( "greek" == type )
        {
            return new ChiChagoGreekPizza();
        }
        return NULL;
    }
};
class NYPizzaFactory : public SimplePizzaFactory
{
public:
    Pizza *CreatePizza(const std::string &type)
    {
        if ( "cheese" == type )
        {
            return new NYCheesePizza();
        }
        if ( "greek" == type )
        {
            return new NYGreekPizza();
        }
        return NULL;
    }
};
class PizzaStore
{
private:
    SimplePizzaFactory &m_pizza_factory;
public:
    PizzaStore(SimplePizzaFactory &pizza_factory) : m_pizza_factory(pizza_factory) {}
    Pizza* OrderPizza(const std::string &type)
    {
        Pizza *p_pizza = m_pizza_factory.CreatePizza(type);
        if (p_pizza)
        {
            p_pizza->prepare();
            p_pizza->bake();
            p_pizza->cut();
            p_pizza->box();
        }
        return p_pizza;
    }
};
int main()
{
    NYPizzaFactory ny_pizza_factory;
    PizzaStore pizza_store(ny_pizza_factory);
    Pizza *p_pizza = pizza_store.OrderPizza("greek");
    if ( p_pizza )
    {
        delete p_pizza;
    }
    return 0;
}