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

问题

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

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

AbstractFactory

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

• ProductA，ProductB：分别代表不同类型的产品，而它们的派生类则是这种产品的一个实现
• AbstractFactory：生产这一系列产品的一个抽象工厂，它的派生类是不同的实现
• 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 
#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 

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;
}

 输出结果

与其他模式的关系

• 建造者模式重点关注如何分步生成复杂对象。 抽象工厂专门用于生产一系列相关对象。抽象工厂会马上返回产品， 建造者模式则允许你在获取产品前执行一些额外构造步骤。
• 抽象工厂模式通常基于一组工厂方法， 但也可以使用原型模式来生成这些类的方法。
• 当只需对客户端代码隐藏子系统创建对象的方式时，可以使用抽象工厂来代替外观模式。
• 可以将抽象工厂和桥接模式搭配使用。如果由桥接定义的抽象只能与特定实现合作，这一模式搭配就非常有用。在这种情况下，抽象工厂可以对这些关系进行封装，并且对客户端代码隐藏其复杂性。