设计模式 -- 抽象工厂模式(AbstactFactory)

抽象工厂模式

抽象工厂模式其实是通过工厂模式实现的，也可以说是工厂模式的扩展。那什么是抽象工厂模式呢？好，先来看看这样一个问题：假设我们玩一个横版过关的游戏，当前关卡有好几类怪物(如：精灵类，人族，鬼…)，每类怪物都有好几十只，那么这种场景对象的创建我们也应该像工厂模式一样把其封装起来管理。抽象工厂模式和工厂模式的区别就是，抽象工厂类是管理一组基类对象，而工厂类只是管理一类基类对象。下面再来看看其结构示例图：

总结：概括地讲，工厂模式和抽象工厂模式都是用来管理对象创建(new)而封装的。而他们的唯一区别就是一个只是管理一类对象的创建，另一个是管理一组对象的创建。

示例

假设有这样一个关卡，包括2种怪物：A类怪和B类怪(一组类对象)。同时这个关卡有两种难度选择：初级和中级(2个工厂类)。下面是这个关卡怪物创建的示例代码：

• A类，B类怪物

#ifndef __DesignMode__Product__
#define __DesignMode__Product__

//A类怪物基类
class AbstractProductA
{
public:
    virtual ~AbstractProductA();
protected:
    AbstractProductA();
};

//B类怪物基类
class AbstractProductB
{
public:
    virtual ~AbstractProductB();
protected:
    AbstractProductB();
};

//初级A类怪物
class ProductA1:public AbstractProductA
{
public:
    ProductA1();
    ~ProductA1();

};

//中级A类怪物
class ProductA2:public AbstractProductA
{
public:
    ProductA2();
    ~ProductA2();
};

//初级B类怪物
class ProductB1:public AbstractProductB
{
public:
    ProductB1();
    ~ProductB1();
};

//中级B类怪物
class ProductB2:public AbstractProductB
{
public:
    ProductB2();
    ~ProductB2();
};

#endif 

#include "Product.h"
#include <iostream> 
using namespace std;

AbstractProductA::AbstractProductA()
{
}

AbstractProductA::~AbstractProductA()
{
}

AbstractProductB::AbstractProductB()
{
}

AbstractProductB::~AbstractProductB()
{
}

ProductA1::ProductA1()
{
    cout << "初级A类怪物..." << endl;
}

ProductA1::~ProductA1()
{
}

ProductA2::ProductA2()
{
    cout << "中级A类怪物..." << endl;
}

ProductA2::~ProductA2()
{

}

ProductB1::ProductB1()
{
    cout << "初级B类怪物..." << endl;
}

ProductB1::~ProductB1()
{
}

ProductB2::ProductB2()
{
    cout << "中级B类怪物..." << endl;
}

ProductB2::~ProductB2()
{
}

• 工厂(基类)：创建初级怪物工厂和创建中级怪物工厂(派生类)

#ifndef __DesignMode__Factory__
#define __DesignMode__Factory__

class AbstractProductA;
class AbstractProductB;

//抽象工厂基类
class AbstractFactory
{
public:
    virtual ~AbstractFactory();
    virtual AbstractProductA* CreateProductA() = 0;
    virtual AbstractProductB* CreateProductB() = 0;
protected:
    AbstractFactory();    //抽象类构造函数写为protected，防止外部构造抽象类
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

#include "Factory.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();
}

• main测试

#include "Factory.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;
}