设计模式—创建型模式—AbstactFactory 模式(抽象工厂模式)

本主题相关博文均转自《设计模式精解-GoF 23 种设计模式解析附 C++实现源码》,作者:K_Eckel

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

模式选择 
AbstractFactory 模式典型的结构图为:

                                                   图 2-1:AbstractFactory Pattern 结构图
AbstractFactory 模式关键就是将这一组对象的创建封装到一个用于创建对象的类(ConcreteFactory) 中, 维护这样一个创建类总比维护 n 多相关对象的创建过程要简单的多。  

实现 
完整代码示例(code) 
AbstractFactory 模式的实现比较简单,这里为了方便初学者的学习和参考,将给出完整的实现代码
代码片断 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_ECT_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) ,大大简化了维护的成本和工作。

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




©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页