[创建型] 简单工厂模式和工厂方法模式

工厂方法模式(factory method)

在工厂方法模式提出之前，有一个简单工厂模式。简单的介绍下简单工程模式，只提供一个工厂类，该工厂类处于对产品类进行实例化的中心位置，他处理每一个产品对象的创建细节。下面列举工厂创建不同品牌的电视机：

/*
* 存在一个TV抽象类，同时也存在多个不同品牌的电视机类，然后在TVFactory类中
* 根据需求实例化不同的电视机类
*/

#include <iostream>
#include <string>
using namespace std;
class TV
{
public:
    TV() {}
    virtual ~TV() {}
    virtual void play() = 0;
};

class HaierTV : public TV
{
public:
    HaierTV() {}
    virtual ~HaierTV() {}
    virtual void play() 
    {
        cout << "这是海尔电视机品牌" << endl;
    }
};
class SonyTV : public TV
{
public:
    SonyTV() {}
    virtual ~SonyTV() {}
    virtual void play()
    {
        cout << "这是sony电视机品牌" << endl;
    }
};

class Factory
{
public:
    Factory() {}
    ~Factory() {}
    TV * ProductTV(string str)
    {
        if(str == "Haier")
        {
            return new HaierTV();
        }
        else if(str == "Sony")
        {
            return new SonyTV();
        }
        else
            return NULL;
    }
};
void main()
{
    string str;
    while(cin >> str)
    {
        Factory f;
        (f.ProductTV(str))->play();
    }
    
}

执行结果：

    输入： Haier

   输出：这是海尔电视机品牌

   输入：Sony

   输出：这是Sony电视机品牌

从中可以看出，Factory类处理了创建电视机的所有细节。当有新品牌的电视机需要加入的时候，那么需要修改Factory类。这在软件工程中来说，违反了开闭原则。

因此，有工厂方法模式的提出：

   解决方法：把工厂Factory也抽象出来，让电视机类的细节处理交予Factory类的子类完成。

意图：
定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method 使一个类的实例化延迟到其子类。

适用性：
当一个类不知道它所必须创建的对象的类的时候。
当一个类希望由它的子类来指定它所创建的对象的时候。
当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是
代理者这一信息局部化的时候。

代码如下:

#include <iostream>
using namespace std;
// 工厂方法模式
/*
 *  抽象产品和抽象工厂 
*/
class AbstructProduct
{
public:
    AbstructProduct() {}
    virtual ~AbstructProduct() {}
    virtual void product() = 0;
};

class AProduct : public AbstructProduct
{
public:
    AProduct() {}
    virtual~AProduct() {}
    virtual void product()
    {
        cout << "这里是A产品" << endl;
    }
};

class BProduct : public AbstructProduct
{
public:
    BProduct() {}
    virtual ~BProduct() {}
    virtual void product()
    {
        cout << "这里是B产品" << endl;
    }
};

class AbstructFactory
{
public:
    AbstructFactory() {}
    virtual ~AbstructFactory() {}
    virtual AbstructProduct * factory() = 0;
};

class AFactory : public AbstructFactory
{
public:
    AFactory() {}
    virtual ~AFactory() {}
    virtual AbstructProduct * factory()
    {
        return new AProduct();
    }
};

class BFactory : public AbstructFactory
{
public:
    BFactory() {}
    virtual ~BFactory() {}
    virtual AbstructProduct*  factory()
    {
        return new BProduct();
    }
};

void main()
{
    AbstructProduct *ap;
    AbstructFactory *af = new AFactory;
    ap = af->factory();
    ap->product();

    AbstructFactory *bf = new BFactory;
    ap = bf->factory();
    ap->product();
}

输出：

    这里是A产品

    这里是B产品