设计模式之AbstractFactory模式

前文降到Factory模式，只能解决同一类的对象创建的问题，现在有如下问题：

假如我们需要开发一块游戏，设置不同的关卡，在不同的关卡需要有不同等级的boss。作为开发者我们就需要设计boss的类，然后初级boss，中级boss，高级boss，BT boss都由该类来派生。在每个关卡我们都需要创建类的实例，可以想象该游戏中我们将会创建成千上万的不同实例，还要保证创建的实例不会出错。

AbstractFactory就是解决类似问题的，创建一组相关或者相互依赖的对象。结构如下图：

AbstractFactory就是这样将一组对象的创建封装到一个用于创建对象的类中，维护这样一个创建类总比维护n多个

相关对象的创建过程要简单得多。

//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_

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()
{
}

//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_

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

//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）。