設計模式（三）——抽象工廠模式

設計模式（三）——抽象工廠模式

一、抽象工廠模式

1、抽象工廠模式簡介

    定義：為創建一組相關或相互依賴的對象提供一個接口，而且無需指定他們的具體類。

UML類圖：

2、抽象工廠模式角色

（1）抽象工廠AbstractFactory：抽象工廠類，提供創建兩種產品的接口CreateProductA和CreateProductB，由派生的各個具體工廠類對其實現

（2）具體工廠：包括具體工廠FactoryM和具體工廠FactoryN。具體工廠FactoryM用于生產具體產品MProductA和具體產品MProductB，具體工廠FactoryN用于生產具體產品NProductA和具體產品NProductB。

（3）抽象產品：AbstractProductA、AbstractProductB：分別代表兩種不同類型的產品，由具體的產品派生類對其實現

（4）具體產品：包括抽象產品AbstractProductA所對應的具體產品MProductA和NProductA，抽象產品AbstractProductB所對應的具體產品MProductB和NProductB。

3、抽象工廠模式優缺點

 優點：抽象工廠模式是對工廠方法模式的改進，用于處理產品不只有一類的情況。抽象工廠模式除了具有工廠方法模式的優點外，最主要的優點就是可以在類的內部對產品族進行約束。所謂的產品族，一般或多或少的都存在一定的關聯，抽象工廠模式就可以在類內部對產品族的關聯關系進行定義和描述，而不必專門引入一個新的類來進行管理。

    抽象工廠模式分離了具體類，使得客戶與類的實現分離

缺點：

    難以支持新種類的產品，不容易擴展。產品族的擴展將是一件十分費力的事情，假如產品族中需要增加一個新的產品，則幾乎所有的工廠類都需要進行修改。所以使用抽象工廠模式時，對產品等級結構的劃分是非常重要的。

    抽象工廠模式和工廠方法模式的區別就在于需要創建對象的復雜程度上。而且抽象工廠模式是三個里面最為抽象、最具一般性的。

4、抽象工廠模式使用場景

抽象工廠模式使用場景：

    A、當需要創建的對象是一系列相互關聯或相互依賴的產品族時，便可以使用抽象工廠模式。一個繼承體系中，如果存在著多個等級結構（即存在著多個抽象類），并且分屬各個等級結構中的實現類之間存在著一定的關聯或者約束，就可以使用抽象工廠模式。假如各個等級結構中的實現類之間不存在關聯或約束，則使用多個獨立的工廠來對產品進行創建，則更合適一點。

    B、 一個系統不應當依賴于產品類實例如何被創建、組合和表達的細節。

    C、同屬于同一個產品族的產品是在一起使用的，約束必須在系統的設計中體現出來。

    D、系統提供一個產品類的庫，所有的產品以同樣的接口出現，從而使客戶端不依賴于實現。

二、抽象工廠模式實現

抽象工廠AbstractFactory類：
#ifndef ABSTRACTFACTORY_H
#define ABSTRACTFACTORY_H
 
class AbstractProductA;
class AbstractProductB;
class AbstractFactory
{
public:
    virtual AbstractProductA* createProductA() = 0;
    virtual AbstractProductB* createProductB() = 0;
};
 
#endif // ABSTRACTFACTORY_H
FactoryM工廠類：
#ifndef FACTORYM_H
#define FACTORYM_H
#include "AbstractFactory.h"
#include "MProductA.h"
#include "MProductB.h"
 
class FactoryM : public AbstractFactory
{
public:
    virtual AbstractProductA* createProductA()
    {
        AbstractProductA* product = new MProductA();
        return product;
    }
    virtual AbstractProductB* createProductB()
    {
        AbstractProductB* product = new MProductB();
        return product;
    }
};
 
#endif // FACTORYM_H
FactoryN工廠類：
#ifndef FACTORYN_H
#define FACTORYN_H
#include "AbstractFactory.h"
#include "NProductA.h"
#include "NProductB.h"
 
class FactoryN : public AbstractFactory
{
public:
    virtual AbstractProductA* createProductA()
    {
        AbstractProductA* product = new NProductA();
        return product;
    }
    virtual AbstractProductB* createProductB()
    {
        AbstractProductB* product = new NProductB();
        return product;
    }
};
 
#endif // FACTORYN_H
 
AbstractProductA抽象產品A類：
#ifndef ABSTRACTPRODUCTA_H
#define ABSTRACTPRODUCTA_H
 
class AbstractProductA
{
public:
    virtual void productMethod() = 0;
};
 
#endif // ABSTRACTPRODUCTA_H
MProductA產品類：
#ifndef MPRODUCTA_H
#define MPRODUCTA_H
#include "AbstractProductA.h"
#include <iostream>
using std::endl;
using std::cout;
 
class MProductA : public AbstractProductA
{
public:
    virtual void productMethod()
    {
        cout << "This is a MProductA by FactoryM" << endl;
    }
};
 
#endif // MPRODUCTA_H
 
NProductA產品類：
#ifndef NPRODUCTA_H
#define NPRODUCTA_H
#include "AbstractProductA.h"
#include <iostream>
using std::endl;
using std::cout;
 
class NProductA : public AbstractProductA
{
public:
    virtual void productMethod()
    {
        cout << "This is a NProductA by FactoryN" << endl;
    }
};
 
#endif // NPRODUCTA_H
 
AbstractProductB抽象產品B類：
#ifndef ABSTRACTPRODUCTB_H
#define ABSTRACTPRODUCTB_H
 
class AbstractProductB
{
public:
    virtual void productMethod() = 0;
};
 
#endif // ABSTRACTPRODUCTB_H
MProductB產品類：
#ifndef MPRODUCTB_H
#define MPRODUCTB_H
#include "AbstractProductB.h"
#include <iostream>
using std::endl;
using std::cout;
 
class MProductB : public AbstractProductB
{
public:
    virtual void productMethod()
    {
        cout << "This is a MProductB by FactoryM" << endl;
    }
};
 
#endif // MPRODUCTB_H
NProductB產品類：
#ifndef NPRODUCTB_H
#define NPRODUCTB_H
#include "AbstractProductB.h"
#include <iostream>
using std::endl;
using std::cout;
 
class NProductB : public AbstractProductB
{
public:
    virtual void productMethod()
    {
        cout << "This is a NProductB by FactoryN" << endl;
    }
};
 
#endif // NPRODUCTB_H
客戶調用程序：
#include <iostream>
#include "AbstractFactory.h"
#include "FactoryM.h"
#include "FactoryN.h"
 
using namespace std;
 
int main()
{
    AbstractFactory* factoryM = new FactoryM();
    AbstractProductA* mproductA = factoryM->createProductA();
    AbstractProductB* mproductB = factoryM->createProductB();
    mproductA->productMethod();
    mproductB->productMethod();
 
    AbstractFactory* factoryN = new FactoryN();
    AbstractProductA* nproductA = factoryN->createProductA();
    AbstractProductB* nproductB = factoryN->createProductB();
    nproductA->productMethod();
    nproductB->productMethod();
 
    delete factoryM;
    delete mproductA;
    delete mproductB;
 
    delete factoryN;
    delete nproductA;
    delete nproductB;
 
    return 0;
}