[设计模式]AbstractFactory抽象工厂模式

问题

假设我们要开发一款游戏，当然为了吸引更多的人玩，游戏难度不能太高但是也不能太简单。于是我们就可以采用这样一种处理策略：为游戏设立等级，初级，中级，高级甚至BT级。假设也是过关的游戏，每个关卡都有一些怪物守着，玩家要把这些怪物干掉才可以过关。作为开发者，我们就不得不创建怪物的类，然后初级怪物，中级怪物等都继承怪物类。在每个关卡，我们都要创建怪物的实例，例如初级要创建初级怪物(有很多种类)，中级创建中级怪物等。可以想象在这个系统中，将会有成千上万的怪物实例要创建，问题是还要保证创建的时候不会出错：初级不能创建BT级的怪物，反之也不可以。

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

AbstractFactory

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

解析

• 1）ProductA，ProductB：分别代表不同类型的产品，而它们的派生类则是这种产品的一个实现
• 2）AbstractFactory：生产这一系列产品的一个抽象工厂，它的派生类是不同的实现
• 3）AbstractFactory：：CreateProductA和AbstractFactory：：CreateProductB：分别是生产不同产品的不同的实现，由各个派生出来的抽象工厂实现之。

AbstractFactory模式和Factory模式最大的差别就是抽象工厂创建的是一系列相关的对象，其中创建的实现其实采用的就是Factory模式的方法，对于某个实现的有一个派生出来的抽象工厂，另一个实现由另一个派生出来的工厂，等等。

抽象工厂需要特别注意的地方就是区别不同类型的产品和这些产品的不同实现。显而易见的，如果有n种产品同时有m种不同的实现，那么根据乘法原理可知有n*m个Factory模式的使用。

 

小demo

abstractFactory.h

#ifndef ABSTRACTFACTORY_H
#define ABSTRACTFACTORY_H

// 抽象基类AbstractProductA,代表产品A的抽象
class AbstractProductA
{
public:
AbstractProductA() {}
virtual ~AbstractProductA(){};
};

// 派生类ConcreateProductA1,继承自AbstractProductA,代表产品A的第一种实现
class ConcreateProductA1 : public AbstractProductA
{
public:
ConcreateProductA1();
virtual ~ConcreateProductA1();
};

// 派生类ConcreateProductA2,继承自AbstractProductA,代表产品A的第二种实现
class ConcreateProductA2 : public AbstractProductA
{
public:
ConcreateProductA2();
virtual ~ConcreateProductA2();
};

// 抽象基类AbstractProductB,代表产品B的抽象
class AbstractProductB
{
public:
AbstractProductB() {}
virtual ~AbstractProductB(){};
};

// 派生类ConcreateProductB1,继承自AbstractProductB,代表产品B的第一种实现
class ConcreateProductB1 : public AbstractProductB
{
public:
ConcreateProductB1();
virtual ~ConcreateProductB1();
};

// 派生类ConcreateProductB2,继承自AbstractProductB,代表产品B的第二种实现
class ConcreateProductB2 : public AbstractProductB
{
public:
ConcreateProductB2();
virtual ~ConcreateProductB2();
};

// 抽象基类AbstractFactory,工厂的抽象类,生产产品A和产品B
class AbstractFactory
{
public:
AbstractFactory(){}
virtual ~AbstractFactory(){}

virtual AbstractProductA* CreateProductA() = 0;
virtual AbstractProductB* CreateProductB() = 0;
};

// 派生类ConcreateFactory1,继承自AbstractFactory
// 生产产品A和产品B的第一种实现
class ConcreateFactory1 : public AbstractFactory
{
public:
ConcreateFactory1();
virtual ~ConcreateFactory1();

virtual AbstractProductA* CreateProductA();
virtual AbstractProductB* CreateProductB();
};

// 派生类ConcreateFactory2,继承自AbstractFactory
// 生产产品A和产品B的第二种实现
class ConcreateFactory2 : public AbstractFactory
{
public:
ConcreateFactory2();
virtual ~ConcreateFactory2();

virtual AbstractProductA* CreateProductA();
virtual AbstractProductB* CreateProductB();
};

#endif

 

abstractFactory.cpp

#include <iostream>
#include "AbstractFactory.h"

ConcreateProductA1::ConcreateProductA1()
{
std::cout << "construction of ConcreateProductA1\n";
}

ConcreateProductA1::~ConcreateProductA1()
{
std::cout << "destruction of ConcreateProductA1\n";
}

ConcreateProductA2::ConcreateProductA2()
{
std::cout << "construction of ConcreateProductA2\n";
}

ConcreateProductA2::~ConcreateProductA2()
{
std::cout << "destruction of ConcreateProductA2\n";
}

ConcreateProductB1::ConcreateProductB1()
{
std::cout << "construction of ConcreateProductB1\n";
}

ConcreateProductB1::~ConcreateProductB1()
{
std::cout << "destruction of ConcreateProductB1\n";
}

ConcreateProductB2::ConcreateProductB2()
{
std::cout << "construction of ConcreateProductB2\n";
}

ConcreateProductB2::~ConcreateProductB2()
{
std::cout << "destruction of ConcreateProductB2\n";
}

ConcreateFactory1::ConcreateFactory1()
{
std::cout << "construction of ConcreateFactory1\n";
}

ConcreateFactory1::~ConcreateFactory1()
{
std::cout << "destruction of ConcreateFactory1\n";
}

AbstractProductA* ConcreateFactory1::CreateProductA()
{
return new ConcreateProductA1();
}

AbstractProductB* ConcreateFactory1::CreateProductB()
{
return new ConcreateProductB1();
}

ConcreateFactory2::ConcreateFactory2()
{
std::cout << "construction of ConcreateFactory2\n";
}

ConcreateFactory2::~ConcreateFactory2()
{
std::cout << "destruction of ConcreateFactory2\n";
}

AbstractProductA* ConcreateFactory2::CreateProductA()
{
return new ConcreateProductA2();
}

AbstractProductB* ConcreateFactory2::CreateProductB()
{
return new ConcreateProductB2();
}

 

main.cpp

#include "AbstractFactory.h"
#include <stdlib.h>

int main()
{
// 生产产品A的第一种实现
ConcreateFactory1 *pFactory1 = new ConcreateFactory1;
AbstractProductA *pProductA = pFactory1->CreateProductA();

// 生产产品B的第二种实现
ConcreateFactory2 *pFactory2 = new ConcreateFactory2;
AbstractProductB *pProductB = pFactory2->CreateProductB();

delete pFactory1;
delete pProductA;
delete pFactory2;
delete pProductB;
system("pause");
return 0;
}

 输出结果