作用：
提供一個建立一系列相關或相互依賴物件的介面， 而無需指定它們具體的類。
抽象基類：
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圖還是要給大家的：