1、问题背景
假设我们要开发一款游戏，当然为了吸引更多的人玩，游戏难度不能太大（让大家都没有信心了，估计游戏也就没有前途了），但是也不能太简单（没有挑战性也不符合玩家的心理）。于是我们就可以采用这样一种处理策略：为游戏设立等级，初级、中级、高级甚至有BT级。假设也是过关的游戏，每个关卡都有一些怪物（monster）守着，玩家要把这些怪物干掉才可以过关。作为开发者，我们就不得不创建怪物的类，然后初级怪物、中级怪物等都继承自怪物类（当然不同种类的则需要另创建类，但是模式相同）。在每个关卡，我们都要创建怪物的实例，例如初级就创建初级怪物（有很多种类）、中级创建中级怪物等。可以想象在这个系统中，将会有成千上万的怪物实例要创建，问题是还要保证创建的时候不会出错：初级不能创建BT级的怪物（玩家就郁闷了，玩家一郁闷，游戏也就挂挂了），反之也不可以。
2、模式示意图
抽象工厂模式示意图
AbstractFactory模式关键就是将一组对象的创建封装到一个用于创建对象的类ConcreteFactory中，维护这样一个创建类总比维护N多相关对象的创建过程要简单的多。
3、代码实现
代码实现如下：
//////////////////////////////////////////////////////////////////////////
//Factory.h
//////////////////////////////////////////////////////////////////////////
#ifndef _FACTORY_H_
#define _FACTORY_H_
#include “Product.h”
class AbstractFactory
{
public:
virtual ~AbstractFactory();
public:
virtual AbstractProductA* fnCreateProductA() = 0;
virtual AbstractProductB* fnCreateProductB() = 0;
protected:
AbstractFactory();
private:
};
class ConcreteFactory1:public AbstractFactory
{
public:
ConcreteFactory1();
~ConcreteFactory1();
public:
AbstractProductA* fnCreateProductA();
AbstractProductB* fnCreateProductB();
protected:
private:
};
class ConcreteFactory2:public AbstractFactory
{
public:
ConcreteFactory2();
~ConcreteFactory2();
public:
AbstractProductA* fnCreateProductA();
AbstractProductB* fnCreateProductB();
protected:
private:
};
#endif //#ifndef _FACTORY_H_
//////////////////////////////////////////////////////////////////////////
//Factory.cpp
//////////////////////////////////////////////////////////////////////////
#include “Factory.h”
#include “Product.h”
#include <iostream>
using namespace std;
AbstractFactory::AbstractFactory()
{
}
AbstractFactory::~AbstractFactory()
{
}
ConcreteFactory1::ConcreteFactory1()
{
}
ConcreteFactory1::~ConcreteFactory1()
{
}
AbstractProductA* ConcreteFactory1::fnCreateProductA()
{
return new ConcreteProductA1();
}
AbstractProductB* ConcreteFactory1::fnCreateProductB()
{
return new ConcreteProductB1();
}
ConcreteFactory2::ConcreteFactory2()
{
}
ConcreteFactory2::~ConcreteFactory2()
{
}
AbstractProductA* ConcreteFactory2::fnCreateProductA()
{
return new ConcreteProductA2();
}
AbstractProductB* ConcreteFactory2::fnCreateProductB()
{
return new ConcreteProductB2();
}
//////////////////////////////////////////////////////////////////////////
//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 ConcreteProductA1:public AbstractProductA
{
public:
ConcreteProductA1();
~ConcreteProductA1();
protected:
private:
};
class ConcreteProductA2:public AbstractProductA
{
public:
ConcreteProductA2();
~ConcreteProductA2();
protected:
private:
};
class ConcreteProductB1:public AbstractProductB
{
public:
ConcreteProductB1();
~ConcreteProductB1();
protected:
private:
};
class ConcreteProductB2:public AbstractProductB
{
public:
ConcreteProductB2();
~ConcreteProductB2();
protected:
private:
};
#endif //#ifndef _PRODUCT_H_
//////////////////////////////////////////////////////////////////////////
//Product.cpp
//////////////////////////////////////////////////////////////////////////
#include “Product.h”
#include <iostream>
using namespace std;
AbstractProductA::AbstractProductA()
{
}
AbstractProductA::~AbstractProductA()
{
}
AbstractProductB::AbstractProductB()
{
}
AbstractProductB::~AbstractProductB()
{
}
ConcreteProductA1::ConcreteProductA1()
{
cout<<“ConcreteProductA1…”<<endl;
}
ConcreteProductA1::~ConcreteProductA1()
{
}
ConcreteProductA2::ConcreteProductA2()
{
cout<<“ConcreteProductA2…”<<endl;
}
ConcreteProductA2::~ConcreteProductA2()
{
}
ConcreteProductB1::ConcreteProductB1()
{
cout<<“ConcreteProductB1…”<<endl;
}
ConcreteProductB1::~ConcreteProductB1()
{
}
ConcreteProductB2::ConcreteProductB2()
{
cout<<“ConcreteProductB2…”<<endl;
}
ConcreteProductB2::~ConcreteProductB2()
{
}
//////////////////////////////////////////////////////////////////////////
//main.cpp
//////////////////////////////////////////////////////////////////////////
#include “Factory.h”
#include <iostream>
using namespace std;
void main()
{
AbstractFactory* pFactory1 = new ConcreteFactory1();
pFactory1->fnCreateProductA();
pFactory1->fnCreateProductB();
AbstractFactory* pFactory2 = new ConcreteFactory2();
pFactory2->fnCreateProductA();
pFactory2->fnCreateProductB();
}
运行结果如下：
4、总结与讨论
AbstractFactory模式是产生多个类型的工厂，而且每个类型的工厂所产生的一序列产品类型不一样（不同的基类）；而Factory模式是产生一个类型的工厂（提供创建接口且延迟对象的创建到子类中实现），产生的产品类型一样（相同的基类）。AbstractFactory模式通常都是使用Factory模式实现。
声明：本站部分文章及图片源自用户投稿，如本站任何资料有侵权请您尽早请联系jinwei@zod.com.cn进行处理,非常感谢！