设计模式之工厂模式

一、模式动机

　　除了使用new操作符 之外，还有更多制造对象的方法。初始化经常造成“耦合”问题，工厂模式可以帮你从复杂的依赖中脱困。

二、模式定义

1、简单工厂模式

　　 简单工厂模式其实不是一个模式，反而比较像是一种编程习惯。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。UML图如下：

• 工厂角色负责实现创建所有实例的内部逻辑；
• 抽象产品角色是所创建的所有对象的父类，负责描述所有实例所共有的公共接口；
• 具体产品角色是创建目标，所有创建的对象都充当这个角色的某个具体类的实例。

2、工厂方法模式

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

3、抽象工厂模式

抽象工厂模式提供了一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。UML类图如下：

三、模式示例

　　以披萨店为例，分别示例简单工厂模式、工厂方法模式和抽象工厂模式。

1、简单工厂模式

C++代码实现：

#include <iostream>
#include <string>

using namespace std;

class Pizza
{
public:
    Pizza();
    ~Pizza();
    virtual void prepare() { cout << "prepare" << endl; }
    virtual void bake() { cout << "bake" << endl; }
    virtual void cut() { cout << "cut" << endl; }
    virtual void box() { cout << "box" << endl; }

private:

};

Pizza::Pizza()
{
}

Pizza::~Pizza()
{
}

class CheesePizza : public Pizza
{
public:
    CheesePizza();
    ~CheesePizza();
    void prepare() { cout << "CheesePizza, prepare" << endl; }

private:

};

CheesePizza::CheesePizza()
{
}

CheesePizza::~CheesePizza()
{
}

class ClamPizza : public Pizza
{
public:
    ClamPizza();
    ~ClamPizza();
    void prepare() { cout << "ClamPizza, prepare" << endl; }

private:

};

ClamPizza::ClamPizza()
{
}

ClamPizza::~ClamPizza()
{
}


class SimplePizzaFactory
{
public:
    SimplePizzaFactory();
    ~SimplePizzaFactory();
    Pizza* createPizza(string type)
    {
        if (type == "ClamPizza")
        {
            return new ClamPizza;
        }
        else if (type == "CheesePizza")
        {
            return new CheesePizza;
        }
        else
            return NULL;
    }

private:

};

SimplePizzaFactory::SimplePizzaFactory()
{
}

SimplePizzaFactory::~SimplePizzaFactory()
{
}

class PizzaStore
{
public:
    PizzaStore(SimplePizzaFactory* factory);
    ~PizzaStore();
    Pizza* orderPizza(string tpye)
    {
        Pizza* pizza = factory_->createPizza(tpye);
        pizza->prepare();
        pizza->bake();
        pizza->cut();
        pizza->box();
        return pizza;
    }

private:
    SimplePizzaFactory* factory_;
};

PizzaStore::PizzaStore(SimplePizzaFactory* factory)
    :factory_(factory)
{
}

PizzaStore::~PizzaStore()
{
}

int _tmain(int argc, _TCHAR* argv[])
{
    //SimpleFactory
    SimplePizzaFactory* factory = new SimplePizzaFactory;
    PizzaStore store(factory);
    Pizza* pizza = store.orderPizza("CheesePizza");
    system("pause");
    return 0;
}

运行结果：

2、工厂方法模式

C++代码实现：

#include <iostream>
#include <string>

using namespace std;

class Pizza
{
public:
    Pizza();
    ~Pizza();
    virtual void prepare() { cout << "prepare" << endl; }
    virtual void bake() { cout << "bake" << endl; }
    virtual void cut() { cout << "cut" << endl; }
    virtual void box() { cout << "box" << endl; }

private:

};

Pizza::Pizza()
{
}

Pizza::~Pizza()
{
}

class CheesePizza : public Pizza
{
public:
    CheesePizza();
    ~CheesePizza();
    void prepare() { cout << "CheesePizza, prepare" << endl; }

private:

};

CheesePizza::CheesePizza()
{
}

CheesePizza::~CheesePizza()
{
}

class ClamPizza : public Pizza
{
public:
    ClamPizza();
    ~ClamPizza();
    void prepare() { cout << "ClamPizza, prepare" << endl; }

private:

};

ClamPizza::ClamPizza()
{
}

ClamPizza::~ClamPizza()
{
}


class PizzaStore
{
public:
    PizzaStore();
    ~PizzaStore();
    virtual Pizza* createPizza(string type) = 0;
    Pizza* orderPizza(string tpye)
    {
        Pizza* pizza = createPizza(tpye);
        pizza->prepare();
        pizza->bake();
        pizza->cut();
        pizza->box();
        return pizza;
    }

private:

};

PizzaStore::PizzaStore()
{
}

PizzaStore::~PizzaStore()
{
}

class ChicagePizzaStore : public PizzaStore
{
public:
    ChicagePizzaStore();
    ~ChicagePizzaStore();
    Pizza* createPizza(string type)
    {
        if (type == "ClamPizza")
        {
            return new ClamPizza;
        }
        else if (type == "CheesePizza")
        {
            return new CheesePizza;
        }
        else
            return NULL;
    }

private:

};

ChicagePizzaStore::ChicagePizzaStore()
{
}

ChicagePizzaStore::~ChicagePizzaStore()
{
}


int _tmain(int argc, _TCHAR* argv[])
{
    //Factory Method
    ChicagePizzaStore store;
    Pizza* pizza = store.orderPizza("ClamPizza");
    system("pause");
    return 0;
}

运行结果：

3、抽象工厂模式

C++代码实现

#include <iostream>
#include <string>

using namespace std;

class Dough
{
public:
    Dough();
    ~Dough();

private:

};

Dough::Dough()
{
}

Dough::~Dough()
{
}

class ThinCrustDough  : public Dough
{
public:
    ThinCrustDough();
    ~ThinCrustDough();

private:

};

ThinCrustDough::ThinCrustDough()
{
    cout << "ThinCrustDough" << endl;
}

ThinCrustDough::~ThinCrustDough()
{
}
class Sauce
{
public:
    Sauce();
    ~Sauce();

private:

};

Sauce::Sauce()
{
}

Sauce::~Sauce()
{
}

class MarinaraSauce : public Sauce
{
public:
    MarinaraSauce();
    ~MarinaraSauce();

private:

};

MarinaraSauce::MarinaraSauce()
{
    cout << "MarinaraSauce" << endl;
}

MarinaraSauce::~MarinaraSauce()
{
}


class PizzaIngredientFactory
{
public:
    PizzaIngredientFactory();
    ~PizzaIngredientFactory();
    virtual Dough* createDough() = 0;
    virtual Sauce* createSauce() = 0;


private:

};

PizzaIngredientFactory::PizzaIngredientFactory()
{
}

PizzaIngredientFactory::~PizzaIngredientFactory()
{
}

class NYPizzaIngredientFactory : public PizzaIngredientFactory
{
public:
    NYPizzaIngredientFactory();
    ~NYPizzaIngredientFactory();
    Dough* createDough() { return new ThinCrustDough; }
    Sauce* createSauce() { return new MarinaraSauce; }

private:

};

NYPizzaIngredientFactory::NYPizzaIngredientFactory()
{
}

NYPizzaIngredientFactory::~NYPizzaIngredientFactory()
{
}

class Pizza
{
public:
    Pizza();
    ~Pizza();
    virtual void prepare() = 0;
    virtual void bake() { cout << "bake" << endl; }
    virtual void cut() { cout << "cut" << endl; }
    virtual void box() { cout << "box" << endl; }

private:

};

Pizza::Pizza()
{
}

Pizza::~Pizza()
{
}

class CheesePizza : public Pizza
{
public:
    CheesePizza(PizzaIngredientFactory* factory);
    ~CheesePizza();
    void prepare() { Dough* dough = factory_->createDough();  Sauce* sauce = factory_->createSauce(); }

private:
    PizzaIngredientFactory* factory_;

};

CheesePizza::CheesePizza(PizzaIngredientFactory* factory)
    :factory_(factory)
{
}

CheesePizza::~CheesePizza()
{
}

class ClamPizza : public Pizza
{
public:
    ClamPizza(PizzaIngredientFactory* factory);
    ~ClamPizza();
    void prepare() { Dough* dough = factory_->createDough();  Sauce* sauce = factory_->createSauce(); }

private:
    PizzaIngredientFactory* factory_;

};

ClamPizza::ClamPizza(PizzaIngredientFactory* factory)
    :factory_(factory)
{
}

ClamPizza::~ClamPizza()
{
}

class PizzaStore
{
public:
    PizzaStore();
    ~PizzaStore();
    virtual Pizza* createPizza(string type) = 0;
    Pizza* orderPizza(string tpye)
    {
        Pizza* pizza = createPizza(tpye);
        pizza->prepare();
        pizza->bake();
        pizza->cut();
        pizza->box();
        return pizza;
    }

private:

};

PizzaStore::PizzaStore()
{
}

PizzaStore::~PizzaStore()
{
}

class ChicagePizzaStore : public PizzaStore
{
public:
    ChicagePizzaStore();
    ~ChicagePizzaStore();
    Pizza* createPizza(string type)
    {
        PizzaIngredientFactory* factory = new NYPizzaIngredientFactory;
        if (type == "ClamPizza")
        {
            return new ClamPizza(factory);
        }
        else if (type == "CheesePizza")
        {
            return new CheesePizza(factory);
        }
        else
            return NULL;
    }

private:

};

ChicagePizzaStore::ChicagePizzaStore()
{
}

ChicagePizzaStore::~ChicagePizzaStore()
{
}


int _tmain(int argc, _TCHAR* argv[])
{
    //Abstract Factory 
    ChicagePizzaStore store;
    Pizza* pizza = store.orderPizza("ClamPizza");
    system("pause");
    return 0;
}

运行结果：

四、分析总结

1. 简单工厂，虽然不是真正的设计模式，但仍不失为一个简单的方法，可以将客户程序从具体类解耦。
2. 工厂方法模式使用继承，把对象的创建委托给子类，子类实现工厂方法来创建对象。
3. 抽象工厂方法的任务是定义一个负责创建一组产品的接口。抽象工厂的每个方法实际上看起来都像是工厂方法。
4. 所有工厂模式都通过减少应用程序和具体类之间的依赖促进松耦合。工厂是很有威力的技巧，帮助我们针对抽象编程，而不要针对具体类编程。