工厂模式

引出工厂模式的设计问题
1.为了提高内聚（Cohesion）和松耦合（Coupling），我们经常会抽象出一些类的公共接口以形成抽象基类或者接口。这样我们可以通过声明一个指向基类的指针来指向实际的子类实现，达到了多态的目的。
2.还有一种情况就是在父类中并不知道具体要实例化哪一个具体的子类。

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

为了使其能更好的解决多种情况的问题，将其分为三类：
简单工厂模式（Simple Factory），工厂方法模式（Factory Method），抽象工厂模式（Abstract Factory）。

简单工厂
具体情形：一个工厂，可以生产固定的几类商品
UML图如下：

对于简单设计模式的结构图，我们可以很清晰的看到它的组成：
1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。
2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。
3) 具体产品角色：工厂类所创建的对象就是此角色的实例。
简单设计模式存在的目的：定义一个用于创建对象的接口。
缺点：对修改不封闭，新增加产品您要修改工厂。违反了鼎鼎大名的开闭法则（OCP）。

代码实现：

#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* CreateSoap(PRODUCTTYPE type)
    {
        switch (type)
        {
        case SFJ:
            return new SFJSoap();
            break;
        case XSL:
            return new XSLSoap();
            break;
        case NAS:
            return new NASSoap();
            break;
        default:
            break;
        }
        return NULL;
    }
};

int main()
{
    Factory factory;
    soapBase* pSoap1 = factory.CreateSoap(SFJ);
    pSoap1->show();
    soapBase* pSoap2 = factory.CreateSoap(XSL);
    pSoap2->show();
    soapBase* pSoap3 = factory.CreateSoap(NAS);
    pSoap3->show();

    delete pSoap1;
    delete pSoap2;
    delete pSoap3;

    return 0;
}

工厂方法模式
具体情形：独立每个生产线，每个生产线只生产一种商品。
UML图如下：

工厂方法模式的应用并不是只是为了封装对象的创建，而是要把对象的创建放到子类中实现：Factory中只是提供了对象创建的接口，其实现将放在Factory的子类ConcreteFactory中进行。

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

代码实现：

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 FactoryBase
{
public:
    virtual soapBase* CreateSoap() = 0;
};

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

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

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

int main()
{
    SFJFactory sfjfac;
    soapBase* psoap1= sfjfac.CreateSoap();
    psoap1->show();
    XSLFactory xslfac;
    soapBase* psoap2= xslfac.CreateSoap();
    psoap2->show();
    NASFactory nasfac;
    soapBase* psoap3= nasfac.CreateSoap();
    psoap3->show();

    delete psoap1;
    delete psoap2;
    delete psoap3;
    return 0;
}

抽象工厂模式
具体情形：一个工厂生产多种商品

抽象工厂模式：给客户端提供一个接口，可以创建多个产品族中的产品对象 ，而且使用抽象工厂模式还要满足以下条件：
1)系统中有多个产品族，而系统一次只可能消费其中一族产品。
2)同属于同一个产品族的产品一起使用。

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

代码实现：

enum PRODUCTTYPE
{
    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 XSLSoap:public soapBase
{
public:
    void show()
    {
        cout<<"XSL 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* CreateSoap() = 0;
    virtual ToothBase* CreateToothpaste() = 0;
};

class factoryA:public FactoryBase
{
public:
    soapBase* CreateSoap()
    {
        return new SFJSoap();
    }
    ToothBase* CreateToothpaste()
    {
        return new HRTooth();
    }
};

class factoryB:public FactoryBase
{
public:
    soapBase* CreateSoap()
    {
        return new NASSoap();
    }
    ToothBase* CreateToothpaste()
    {
        return new ChinaTooth();
    }
};

int main()
{
    factoryA factory1;
    factoryB factory2;
    soapBase* psoap1 = NULL;
    ToothBase* ptoothpaste1 = NULL;
    psoap1 = factory1.CreateSoap();
    ptoothpaste1 = factory1.CreateToothpaste();
    psoap1->show();
    ptoothpaste1->show();

    soapBase* psoap2 = NULL;
    ToothBase* ptoothpaste2 = NULL;
    psoap2 = factory2.CreateSoap();
    ptoothpaste2 = factory2.CreateToothpaste();
    psoap2->show();
    ptoothpaste2->show();

    delete psoap1;
    delete psoap2;
    delete ptoothpaste1;
    delete ptoothpaste2;
}