AbstactFactory模式

問題場景

假設我們設計一個遊戲，可以採用這樣一種處理策略： 為遊戲設立等級，初級、中級、高階甚至有BT 級。 假設也是過關的遊戲， 每個關卡都有一些怪物（monster） 守著， 玩家要把這些怪物幹掉才可以過關。 作為開發者， 我們就不得不建立怪物的類， 然後初級怪物、 中級怪物等都繼承自怪物類（當然不同種類的則需要另建立類，但是模式相同）。在每個關卡， 我們都要建立怪物的例項，例如初級就建立初級怪物（有很多種類）、中級建立中級怪物等。可以想象在這個系統中， 將會有成千上萬的怪物例項要建立， 問題是還要保證建立的時候不會出錯：初級不能建立 BT 級的怪物（玩家就鬱悶了，玩家一鬱悶，遊戲也就掛掛了），反之也不可以。

AbstractFactory 模式就是用來解決這類問題的：要建立一組相關或者相互依賴的物件。

AbstractFactory 模式關鍵就是將這一組物件的建立封裝到一個用於建立物件的類 （ConcreteFactory）中， 維護這樣一個建立類總比維護 n 多相關物件的建立過程要簡單的多。

實現

//Product.h

#ifndef _PRODUCT_H_
#define _PRODUCT_H_

class AbstractProductA
{
public:
virtual ~AbstractProductA();
protected:
AbstractProductA
 
();
private:
};
class AbstractProductB
{
public:
virtual ~AbstractProductB();
protected:
AbstractProductB();
private:
};
class ProductA1:public AbstractProductA
{
public:
ProductA1();
~ProductA1();
protected:
private:
};

class ProductA2:public AbstractProductA
{
public:
ProductA2();
~ProductA2();
protected
 
:
private:
};
class ProductB1:public AbstractProductB
{
public:
ProductB1();
~ProductB1();
protected:
private:
};
class ProductB2:public AbstractProductB
{
public:
ProductB2();
~ProductB2();
protected:
private:
};
#endif //~_PRODUCT_H_

#include "Product.h"
AbstractProductA::AbstractProductA()
{
}
AbstractProductA::~AbstractProductA()
{
}
AbstractProductB::AbstractProductB()
{
}
AbstractProductB::~AbstractProductB()
{
}
ProductA1::ProductA1()
{
cout<<"ProductA1..."<<endl;
}
ProductA1::~ProductA1()
{
}
ProductA2::ProductA2()
{
cout<<"ProductA2..."<<endl;
}
ProductA2::~ProductA2()
{
}
ProductB1::ProductB1()
{
cout<<"ProductB1..."<<endl;
}
ProductB1::~ProductB1()
{
}
ProductB2::ProductB2()
{
cout<<"ProductB2..."<<endl;
}
ProductB2::~ProductB2()
{
}

//AbstractFactory.h
#ifndef _ABSTRACTFACTORY_H_
#define _ABSTRACTFACTORY_H_
class AbstractProductA;
class AbstractProductB;
class AbstractFactory
{
public:
virtual ~AbstractFactory();
virtual AbstractProductA* CreateProductA() = 0;
virtual AbstractProductB* CreateProductB() = 0;
protected:
AbstractFactory();
private:
};
class ConcreteFactory1:public AbstractFactory
{
public:
ConcreteFactory1();
~ConcreteFactory1();
AbstractProductA* CreateProductA();
AbstractProductB* CreateProductB();
protected:
private:
};
class ConcreteFactory2:public AbstractFactory
{
public:
ConcreteFactory2();
~ConcreteFactory2();
AbstractProductA* CreateProductA();
AbstractProductB* CreateProductB();
protected:
private:
};
#endif //~_ABSTRACTFACTORY_H_

//AbstractFactory.cpp
#include "AbstractFactory.h"
#include "Product.h"
AbstractFactory::AbstractFactory()
{
}
AbstractFactory::~AbstractFactory()
{
}
ConcreteFactory1::ConcreteFactory1()
{
}
ConcreteFactory1::~ConcreteFactory1()
{
}
AbstractProductA* ConcreteFactory1::CreateProductA()
{
return new ProductA1();
}
AbstractProductB* ConcreteFactory1::CreateProductB()
{
return new ProductB1();
}
ConcreteFactory2::ConcreteFactory2()
{
}
ConcreteFactory2::~ConcreteFactory2()
{
}
AbstractProductA* ConcreteFactory2::CreateProductA()
{
return new ProductA2();
}
AbstractProductB* ConcreteFactory2::CreateProductB()
{
return new ProductB2();
}

//main.cpp
#include "AbstractFactory.h"
nt main(int argc,char* argv[])
{
AbstractFactory* cf1 = new ConcreteFactory1();
cf1->CreateProductA();
cf1->CreateProductB();
AbstractFactory* cf2 = new ConcreteFactory2();
cf2->CreateProductA();
cf2->CreateProductB();
return 0;
}

AbstractFactory 模式的實現程式碼很簡單， 在測試程式中可以看到， 當我們要建立一組物件（ProductA1， ProductA2）的時候我們只用維護一個建立物件（ConcreteFactory1），大大簡化了維護的成本和工作。

AbstractFactory 模式和 Factory 模式的區別是初學（使用）設計模式時候的一個容易引起困惑的地方。 實際上， AbstractFactory 模式是為建立一組（有多類） 相關或依賴的物件提供建立介面， 而 Factory 模式正如我在相應的文件中分析的是為一類物件提供建立介面或延遲物件的建立到子類中實現。並且可以看到， AbstractFactory 模式通常都是使用 Factory 模式實現（ConcreteFactory1）。