工厂方法模式(Product)C++实现

意图：定义一个用于创建对象的接口，让子类觉定实例化哪一个类。

适用性：1.一个类不知道它必须创建的对象的时候。

　　　　2.一个类希望由它的子类指定它所创建的对象的时候。

　　　　3.当类将创建对象的职责委托给多个帮助子类中的某一个，并且希望将那一个帮助子类是代理者这一信息局部化的时候。

效果： 1.提供对象的扩展版本。

　　　　2.连接平行的类层次。

今天学工厂方法模式，感觉得从几个工厂模式一起去理解，所以我整体的讲一下自己的想法。

开始，老板要求按客户意愿产生对应产品。于是有简单工厂，代码如下：

#ifndef _PRODUCT_

#define _PRODUCT_

#include <string>

using namespace std;

class AbsProduct{

public:

    AbsProduct(){}

    virtual string GetProduct() = ;

};

class Product_A:public AbsProduct{

public:

    Product_A(){}

    virtual string GetProduct(){return "Product_A";}

};

class Product_B:public AbsProduct{

public:

    Product_B(){}

    virtual string GetProduct(){return "Product_B";}

};

class Product_C:public AbsProduct{

public:

    Product_C(){}

    virtual string GetProduct(){return "Product_C";}

};

#endif

产品部分代码

工厂部分代码：

#ifndef _FACTORY_

#define _FACTORY_

#include "Product.h"

class Factory{

public:

    Factory(){}

    AbsProduct* MakeProduct(char ch)

    {

        switch (ch)

        {

        case 'A':

            return new Product_A;

            break;

        case 'B':

            return new Product_B;

            break;

        case 'C':

            return new Product_C;

            break;

        default:

            break;

        }

    }

};

#endif

实现部分：

#include <iostream>

#include <string>

using namespace std;

#include "Factory.h"

#include "Product.h"

int main()

{

    Factory factory;

    AbsProduct* product = factory.MakeProduct('A');

    cout<<product->GetProduct()<<endl;

    product = factory.MakeProduct('B');

    cout<<product->GetProduct()<<endl;

    product = factory.MakeProduct('C');

    cout<<product->GetProduct()<<endl;

    return ;

}

有一天，老板又要求：将新产品 Product_D 加入到生产。简单工厂模式虽然满足了按要求生产对应的产品，

但无法扩展新产品。于是实现了工厂方法模式：

首先产品部分添加Product_D ：

class Product_D:public AbsProduct{

public:

    Product_D(){}

    virtual string GetProduct(){return "Product_D";}

};

工厂部分改为：

class AbsFactory{

public:

    AbsFactory(){}

    virtual AbsProduct* MakeFroduct() = ;

};

class Factory_A:public AbsFactory{

public:

    Factory_A(){}

    virtual AbsProduct* MakeFroduct(){return new Product_A;}

};

class Factory_B:public AbsFactory{

public:

    Factory_B(){}

    virtual AbsProduct* MakeFroduct(){return new Product_B;}

};

class Factory_C:public AbsFactory{

public:

    Factory_C(){}

    virtual AbsProduct* MakeFroduct(){return new Product_C;}

};

class Factory_D:public AbsFactory{

public:

    Factory_D(){}

    virtual AbsProduct* MakeFroduct(){return new Product_D;}

};

工厂方法工厂部分代码

实现部分：

#include <iostream>

#include <string>

using namespace std;

#include "Factory.h"

#include "Product.h"

int main()

{

    AbsFactory* factory = new Factory_A;

    AbsProduct* product = factory->MakeFroduct();

    cout<<product->GetProduct()<<endl;

    factory = new Factory_B;

    product = factory->MakeFroduct();

    cout<<product->GetProduct()<<endl;

    factory = new Factory_C;

    product = factory->MakeFroduct();

    cout<<product->GetProduct()<<endl;

    factory = new Factory_D;

    product = factory->MakeFroduct();

    cout<<product->GetProduct()<<endl;

    return ;

}

老板又要求了，“现在我们公司就主打这四个产品了，你们要定期更新这些产品。”

这样工厂方法虽然满足了按客户要求生产对应产品，而且也满足了扩展新产品的要求，

但无法满足新产品的更新换代。于是抽象工厂模式出来了......

对于我们的例子而已，假设公司的产品A1,B1,C1,D1为一起产品，A2,B2,C2,D2为二期产品。

则A1，A2，A3......为同一族产品。而A1,B1,C1,D1为同一等级产品。如果只工厂生产同一等级

产品，则是工厂方法模式。如果产生了不同等级产品则为抽象工厂模式。

巴特西

工厂方法模式(Product)C++实现

最新文章

热门文章