0 引言
0.1 目的
本文檔給出設計模式之——AbstractFactory模式的簡化詮釋，并給出其C++實現。
0.2 說明
|
Project
|
Design Pattern Explanation（By K_Eckel）
|
|
Authorization
|
Free Distributed but Ownership Reserved
|
|
Date
|
|
|
Test Bed
|
MS Visual C++ 6.0
|
0.3 參考
在本文檔的寫作中，參考了以下的資源，在此列出表示感謝：
u 書籍
[GoF 2000]：GoF,Design Patterns-Elements of Reusable Object-Oriented Software
Addison-Wesley 2000/9.
[Martine 2003]：Robert C.Martine, Agile Software Development Principles, Patterns, and Practices, Pearson Education, 2003.
0.4 聯系作者
|
Author
|
K_Eckel
|
|
State
|
Candidate for Master’s Degree School of
|
|
E_mail
|
frwei@whu.edu.cn
|
2 AbstractFactory模式
2.1 問題
假設我們要開發一款游戲，當然為了吸引更多的人玩，游戲難度不能太大（讓大家都沒有信心了，估計游戲也就沒有前途了），但是也不能太簡單（沒有挑戰性也不符合玩家的心理）。于是我們就可以采用這樣一種處理策略：為游戲設立等級，初級、中級、高級甚至有BT級。假設也是過關的游戲，每個關卡都有一些怪物（monster）守著，玩家要把這些怪
物干掉才可以過關。作為開發者，我們就不得不創建怪物的類，然后初級怪物、中級怪物等都繼承自怪物類（當然不同種類的則需要另創建類，但是模式相同）。在
每個關卡，我們都要創建怪物的實例，例如初級就創建初級怪物（有很多種類）、中級創建中級怪物等。可以想象在這個系統中，將會有成千上萬的怪物實例要創
建，問題是還要保證創建的時候不會出錯：初級不能創建BT級的怪物（玩家就郁悶了，玩家一郁悶，游戲也就掛掛了），反之也不可以。
AbstractFactory模式就是用來解決這類問題的：要創建一組相關或者相互依賴的對象。
2.2 模式選擇
AbstractFactory模式典型的結構圖為：
圖2-1：AbstractFactoryPattern結構圖
AbstractFactory模式關鍵就是將這一組對象的創建封裝到一個用于創建對象的類（ConcreteFactory）中，維護這樣一個創建類總比維護n多相關對象的創建過程要簡單的多。
2.3 實現
AbstractFactory模式的實現比較簡單，這里為了方便初學者的學習和參考，將給出完整的實現代碼（所有代碼采用C++實現，并在VC 6.0下測試運行）。
|
代碼片斷1：Product.h
//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_
|
|
代碼片斷2：Product.cpp
//Product.cpp
#include "Product.h"
#include <iostream>
using namespace std;
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()
{
}
|
|
代碼片斷3：AbstractFactory.h
//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_
|
|
代碼片斷4：AbstractFactory.cpp
//AbstractFactory.cpp
#include "AbstractFactory.h"
#include "Product.h"
#include <iostream>
using namespace std;
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();
}
|
|
代碼片斷5：main.cpp
//main.cpp
#include "AbstractFactory.h"
#include <iostream>
using namespace std;
int 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），大大簡化了維護的成本和工作。
2.4 討論
AbstractFactory模式和Factory模式的區別是初學（使用）設計模式時候的一個容易引起困惑的地方。實際上，AbstractFactory模式是為創建一組（有多類）相關或依賴的對象提供創建接口，而Factory模式正如我在相應的文檔中分析的是為一類對象提供創建接口或延遲對象的創建到子類中實現。并且可以看到，AbstractFactory模式通常都是使用Factory模式實現（ConcreteFactory1）。