由遇到的问题引出抽象工厂模式

由遇到的问题引出抽象工厂模式

假设我们要开发一款游戏，当然为了吸引更多的人玩，游戏难度不能太大（让大家都没有信心了，估计游戏也就没有前途了），但是也不能太简单（没有挑战性也不符合玩家的心理）。于是我们就可以采用这样一种处理策略：为游戏设立等级，初级、中级、高级甚至有BT 级。假设也是过关的游戏，每个关卡都有一些怪物（monster）守着，玩家要把这些怪物干掉才可以过关。作为开发者，我们就不得不创建怪物的类，然后初级怪物、中级怪物等都继承自怪物类（当然不同种类的则需要另创建类，但是模式相同）。在每个关卡，我们都要创建怪物的实例，例如初级就创建初级怪物（有很多种类）、中级创建中级怪物等。可以想象在这个系统中，将会有成千上万的怪物实例要创建，问题是还要保证创建的时候不会出错：初级不能创建 BT 级的怪物（玩家就郁闷了，玩家一郁闷，游戏也就挂挂了），反之也不可以。

抽象工厂模式就是用来解决这类问题的：要创建一组相关或者相互依赖的对象。

模式选择

抽象工厂模式典型的结构图为：

图 2-1：抽象工厂模式结构图

抽象工厂模式关键就是将这一组对象的创建封装到一个用于创建对象的类（ConcreteFactory）中，维护这样一个创建类总比维护 n 多相关对象的创建过程要简单的多。

抽象工厂模式的实现

完整代码示例（code） ：抽象工厂模式的实现比较简单，这里为了方便初学者的学习和参考，将给出完整的实现代码（所有代码采用 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;
}

代码说明 ：抽象工厂模式的实现代码很简单，在测试程序中可以看到，当我们要创建一组对象（ProductA1，ProductA2）的时候我们只用维护一个创建对象（ConcreteFactory1），大大简化了维护的成本和工作。

关于抽象工厂模式的讨论

抽象工厂模式和工厂模式的区别是初学（使用）设计模式时候的一个容易引起困惑的地方。实际上，抽象工厂模式是为创建一组（有多类）相关或依赖的对象提供创建接口，而 Factory 模式正如我在相应的文档中分析的是为一类对象提供创建接口或延迟对象的创建到子类中实现。并且可以看到，抽象工厂模式通常都是使用工厂模式实现（ConcreteFactory1）。