抽象工厂模式（AbstractFactory）-设计模式（二）

作用：
提供一个创建一系列相关或相互依赖对象的接口， 而无需指定它们具体的类。
抽象基类：
1)ProductA,ProductB:分别代表不同类型的产品,而它们的派生类则是这种产品的一
个实现.
2)AbstractFactory:生产这一系列产品的一个抽象工厂,它的派生类是不同的实现.
接口函数：
1)AbstractFactory::CreateProductA 和 AbstractFactory::CreateProductB:
分别是生产不同产品的不同的实现， 由各个派生出来的抽象工厂实现之.
解析：
Abstract Factory 模式和 Factory 最大的差别就是抽象工厂创建的是一系列相关的对象,
其中创建的实现其实采用的就是 Factory 模式的方法,对于某个实现的有一个派生出来的
抽象工厂， 另一个实现有另一个派生出来的工厂,等等.
抽象工厂需要特别注意的地方就是区分不同类型的产品和这些产品的不同实现.显而易
见的,如果有 n 种产品同时有 m 中不同的实现,那么根据乘法原理可知有 n*m 个
Factory 模式的使用.
当然举例还是离开不了吃货的本行，我们来看看一个简单的例子吧！
鸡腿和汉堡，都可以由商店出售，但是呢，实现的方法不同，肯德基和麦当劳能够生产出不同风味的鸡腿和汉堡，如果能生产同样风味那不就一家店了嘛。而怎样生产鸡腿和汉堡不就是上次所说的工厂模式嘛。
再来看一下简单的实现：

#include<iostream>

using namespace std;

//抽象基类AbstractProductA,代表鸡腿的抽象
class AbstractProductA
{
    public:
    AbstractProductA(){}
    virtual ~AbstractProductA(){}
};
//派生类ConcreateProductA1,继承自AbstractProductA,代表鸡腿的第一种实现，肯德基生产
class ConcreateProductA1:public AbstractProductA
{
    public:
        ConcreateProductA1()
        {
            cout<<"肯德基生产鸡腿"<<endl; 
        }
        virtual ~ConcreateProductA1(){}
};
//派生类ConcreateProductA2,继承自AbstractProductA,代表产鸡腿的第二种实现，麦当劳生产
class ConcreateProductA2:public AbstractProductA
{
    public:
        ConcreateProductA2()
        { 
            cout<<"麦当劳生产鸡腿"<<endl; 
        }
        virtual ~ConcreateProductA2(){}
};
//抽象基类AbstractProductB,代表汉堡的抽象
class AbstractProductB
{
    public:
        AbstractProductB(){}
        virtual ~AbstractProductB(){}
};
//派生类ConcreateProductB1,继承自AbstractProductB,代表汉堡的第一种实现，肯德基生产
class ConcreateProductB1:public AbstractProductB
{
    public:
        ConcreateProductB1()
        { 
            cout<<"肯德基生产汉堡"<<endl; 
        }
        virtual ~ConcreateProductB1(){}
};
//派生类ConcreateProductB2,继承自AbstractProductB,代表汉堡的第二种实现，麦当劳生产
class ConcreateProductB2:public AbstractProductB
{
    public:
        ConcreateProductB2()
        { 
            cout<<"麦当劳生产汉堡"<<endl; 
        }
        virtual ~ConcreateProductB2(){}
};
//抽象基类AbstractFactory,工厂的抽象类，生产鸡腿和汉堡
class AbstractFactory
{
    public:
        AbstractFactory(){}
        virtual ~AbstractFactory(){}
        virtual AbstractProductA* CreateProductA()=0;
        virtual AbstractProductB* CreateProductB()=0;
};
// 派生类 ConcreateFactoryl,继承自 AbstractFactory,生产鸡腿和汉堡的第一种实现，肯德基
class ConcreteFactory1:public AbstractFactory
{
    public:
        ConcreteFactory1()
        { 
            cout<<"肯德基"<<endl; 
        }
        virtual ~ConcreteFactory1(){}
        virtual AbstractProductA* CreateProductA()
        { 
            return new ConcreateProductA1(); 
        }
        virtual AbstractProductB* CreateProductB()
        { 
            return new ConcreateProductB1(); 
        }
};
// 派生类 ConcreateFactory2,继承自 AbstractFactory生产鸡腿和汉堡的第二种实现，麦当劳
class ConcreteFactory2:public AbstractFactory
{
    public:
        ConcreteFactory2()
        {
            cout<<"麦当劳"<<endl; 
        }
        virtual ~ConcreteFactory2(){}
        virtual AbstractProductA* CreateProductA()
        { 
            return new ConcreateProductA2(); 
        }
        virtual AbstractProductB* CreateProductB()
        { 
            return new ConcreateProductB2(); 
        }
};
int main()
{
    //生产鸡腿的第一种实现
    AbstractFactory *cf1 = new ConcreteFactory1();
    cf1->CreateProductA();
    //生产汉堡的第二种实现
    AbstractFactory *cf2 = new ConcreteFactory2();
    cf2->CreateProductB();
    delete cf1;
    delete cf2;
    return 0;
}

渔我已经给大家啦，怎样才能钓到鱼呢，就看大伙的啦！
下面是我理解的抽象工厂：

当然，网上找的UML图还是要给大家的：