设计模式：工厂模式

最新推荐文章于 2024-06-18 22:44:42 发布

啊啊啊西吧

最新推荐文章于 2024-06-18 22:44:42 发布

阅读量387

点赞数 1

分类专栏： C/C++ 文章标签：工厂模式

C/C++ 专栏收录该内容

43 篇文章 1 订阅

订阅专栏

在面向对象系统设计中经常可以遇到以下的两类问题：
◆ 1.为了提高内聚（Cohesion）和松耦合（Coupling），我们经常会抽象出一些类的公共接口以形成抽象基类或者接口。这样我们可以通过声明一个指向基类的指针来指向实际的子类实现，达到了多态的目的。这里很容易出现的一个问题 n 多的子类继承自抽象基类，我们不得不在每次要用到子类的地方就编写诸如 new ×××;的代码。
这里带来两个问题：

客户程序员必须知道实际子类的名称（当系统复杂后，命名将是一个很不好处理的问题，为了处理可能的名字冲突，有的命名可能并不是具有很好的可读性和可记忆性，就姑且不论不同程序员千奇百怪的个人偏好了）。
程序的扩展性和维护变得越来越困难。

◆ 2.还有一种情况就是在父类中并不知道具体要实例化哪一个具体的子类。这里的意思为：假设我们在类 A 中要使用到类 B，B 是一个抽象父类，在 A 中并不知道具体要实例化那一个 B 的子类，但是在类 A 的子类 D 中是可以知道的。在 A 中我们没有办法直接使用类似于 new ×××的语句，因为根本就不知道×××是什么。

以上两个问题也就引出了工厂模式的两个最重要的功能：
定义创建对象的接口，封装了对象的创建；
使得具体化类的工作延迟到了子类中。

具体情形：有一个肥皂厂，生产各种肥皂，有舒肤佳，夏士莲，娜爱斯等。给这个肥皂厂建模。
分析组成：
1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。
2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。
3) 具体产品角色：工厂类所创建的对象就是此角色的实例。
看代码就会一目了然：

#include <iostream>
using namespace std;
enum PRODUCTTYPE {SFJ,XSL,NAS};
class soapBase
{
    public:
    virtual ~soapBase(){};
    virtual void show() = 0;
};

class SFJSoap:public soapBase
{
    public:
    void show() {cout<<"SFJ Soap!"<<endl;}
};

class XSLSoap:public soapBase
{
    public:
    void show() {cout<<"XSL Soap!"<<endl;}
};

class NASSoap:public soapBase
{
    public:
    void show() {cout<<"NAS Soap!"<<endl;}
};

class Factory
{
    public:
    soapBase * creatSoap(PRODUCTTYPE type)
    {
        switch(type)
        {
            case SFJ: 
                return new SFJSoap();
                break;
            case XSL:
                return new XSLSoap();
                break;
            case NAS:
                return new NASSoap();
                break;
            default:break;
        }

    }
};

int main()
{
    Factory factory;
    soapBase* pSoap1 = factory.creatSoap(SFJ);
    pSoap1->show();
    soapBase* pSoap2 = factory.creatSoap(XSL);
    pSoap2->show();
    soapBase* pSoap3 = factory.creatSoap(NAS);
    pSoap3->show();
    delete pSoap1;
    delete pSoap2;
    delete pSoap3;
    return 0;
}

简单设计模式存在的目的很简单：定义一个用于创建对象的接口。
缺点：对修改不封闭，新增加产品您要修改工厂（因为工厂里要去判断生成哪一个具体的产品类）。违背了设计模式6大原则中的：
开闭法则：
一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。
也就是尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化
这种我们称作简单工厂模式。

情形2：

具体情形：最近莫名肥皂需求激增!！于是要独立每个生产线，每个生产线只生产一种肥皂。
组成分析：
1)抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。
2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。
4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。

代码实现：

#include <iostream>
using namespace std;
enum SOAPTYPE {SFJ,XSL,NAS};

class soapBase
{
    public:
    virtual ~soapBase(){};
    virtual void show() = 0;
};

class SFJSoap:public soapBase
{
    public:
    void show() {cout<<"SFJ Soap!"<<endl;}
};

class XSLSoap:public soapBase
{
    public:
    void show() {cout<<"XSL Soap!"<<endl;}
};

class NASSoap:public soapBase
{
    public:
    void show() {cout<<"NAS Soap!"<<endl;}
};

class FactoryBase
{
    public:
    virtual soapBase * creatSoap() = 0;
};

class SFJFactory:public FactoryBase
{
    public:
    soapBase * creatSoap()
    {
        return new SFJSoap();
    }
};

class XSLFactory:public FactoryBase
{
    public:
    soapBase * creatSoap()
    {
        return new XSLSoap();
    }
};

class NASFactory:public FactoryBase
{
    public:
    soapBase * creatSoap()
    {
        return new NASSoap();
    }
};



int main()
{
    SFJFactory factory1;
    soapBase* pSoap1 = factory1.creatSoap();
    pSoap1->show();
    XSLFactory factory2;
    soapBase* pSoap2 = factory2.creatSoap();
    pSoap2->show();
    NASFactory factory3;
    soapBase* pSoap3 = factory3.creatSoap();
    pSoap3->show();
    delete pSoap1;
    delete pSoap2;
    delete pSoap3;
    return 0;
}

其实这才是真正的工厂模式，简单工厂模式只能算是“坑爹版”的工厂模式。我们能很容易看出工厂方法模式和简单工厂模式的区别之处。工厂方法模式的应用并不是只是为了封装对象的创建，而是要把对象的创建放到子类中实现：Factory中只是提供了对象创建的接口，其实现将放在Factory的子类ConcreteFactory中进行。
这种我们称为：工厂方法模式

缺点：每增加一种产品，就需要增加一个对象的工厂。如果这家公司发展迅速，推出了很多新的处理器核，那么就要开设相应的新工厂。在C++实现中，就是要定义一个个的工厂类。显然，相比简单工厂模式，工厂方法模式需要更多的类定义。

情形3：
具体情形：这个肥皂厂发现搞牙膏也很赚钱，决定做牙膏。牙膏有高档低档，肥皂也是。现在搞两个厂房，一个生产低档的牙膏和肥皂，一个生产高档的牙膏和肥皂。比如，厂房一生产中华牙膏、娜爱斯肥皂，厂房二生产黑人牙膏和舒肤佳牙膏

组成：
抽象工厂模式的组成（和工厂方法模式一样）：
1)抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。
2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。
4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。
代码实现：

#include <iostream>
using namespace std;
enum SOAPTYPE {SFJ,XSL,NAS};
enum TOOTHTYPE {HR,ZH};

class SoapBase
{
    public:
    virtual ~SoapBase(){};
    virtual void show() = 0;
};

class SFJSoap:public SoapBase
{
    public:
    void show() {cout<<"SFJ Soap!"<<endl;}
};

class NASSoap:public SoapBase
{
    public:
    void show() {cout<<"NAS Soap!"<<endl;}
};

class ToothBase
{
    public:
    virtual ~ToothBase(){};
    virtual void show() = 0;
};

class HRTooth:public ToothBase
{
    public:
    void show() {cout<<"Hei ren Toothpaste!"<<endl;}
};

class ChinaTooth:public ToothBase
{
    public:
    void show() {cout<<"China Toothpaste!"<<endl;}
};

class FactoryBase
{
    public:
    virtual SoapBase * creatSoap() = 0;
    virtual ToothBase * creatToothpaste() = 0;
};

class FactoryA :public FactoryBase
{
    public:
    SoapBase * creatSoap()
    {
        return new SFJSoap();
    }

    ToothBase * creatToothpaste()
    {
        return new HRTooth();
    }
};

class FactoryB :public FactoryBase
{
    public:
    SoapBase * creatSoap()
    {
        return new NASSoap();
    }

    ToothBase * creatToothpaste()
    {
        return new ChinaTooth();
    }
};


int main()
{
    FactoryA factory1;
    FactoryB factory2;

    SoapBase *pSoap1 = NULL;
    ToothBase *pToothpaste1 = NULL;

    pSoap1 = factory1.creatSoap();
    pToothpaste1 = factory1.creatToothpaste();
    pSoap1->show();
    pToothpaste1->show();

    SoapBase *pSoap2 = NULL;
    ToothBase *pToothpaste2 = NULL;
    pSoap2 = factory2.creatSoap();
    pToothpaste2 = factory2.creatToothpaste();
    pSoap2->show();
    pToothpaste2->show();

    delete pSoap1;
    delete pSoap2;
    delete pToothpaste1;
    delete pToothpaste2;

    return 0;
}