设计模式学习4——抽象工厂模式

参看：刘伟 设计模式 http://blog.csdn.net/lovelion/article/details/9319323
一、产品等级结构和产品族

产品等级结构也就是产品的继承结构，如一个抽象类是电视机，其子类是海尔电视机、海信电视机、TCL电视机等，则抽象电视机与具体品牌的电视机之间构成了一个产品等级结构。

产品族是指由一个工厂生产的，位于不同产品等级结构中的一组产品。

产品等级结构与产品族示意图如图3所示：



图3 产品族与产品等级结构示意图

如上图，不同颜色的多个正方形、圆形和椭圆分别构成了三个不同的产品等级结构，而颜色相同的正方形、圆形和椭圆构成一个产品族，每个形状对象位于一个产品族，并属于某个产品等级结构。

二、抽象工厂模式与工厂方法模式

抽象工厂模式是所有形式的工厂模式中最为抽象和最具一般性的一种形式。

抽象工厂模式与工厂方法模式最大的区别在于：工厂方法模式针对的只是一个产品等级结构，而抽象工厂模式需要面对多个产品等级结构，其中一个工厂等级结构可以负责多个不同产品等级结构中的产品对象的创建。当一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族的所有对象时，抽象工厂模式比工厂方法模式更为简单、更为有效。

工厂方法模式中每个工厂只生产一种产品，当系统中存在多个产品等级结构时，就需要创建大量的工厂类；使用抽象工厂模式一个具体工厂负责创建一个产品族中的所有具体产品，极大地减少了系统中工厂类的数量，例如，若使用工厂方法模式图3中有十五个形状，就需要一个抽象产品类和15个具体产品类，还需要一个抽象工厂类和15个具体工厂类；若使用抽象工厂模式，则需要一个抽象产品虚基类，5个产品族类，每个产品族类派生三个具体形状类，需要5个抽象工厂类，每个抽象工厂类负责一个产品族的中具体形状的创建。

假设我们有n个产品族，每个产品族下有m个具体产品，则：

使用工厂方法模式，需要的类的总数是：1（一个抽象产品类）+m*n（具体产品类）+1（一个抽象工厂类）+m*n（具体工厂类） = 2+2*m*n

使用抽象工厂模式, 需要的类的总数是：n（抽象产品族类）+m*n(具体产品类) +1（抽象工厂类）+n(具体工厂类) = （m+2）*n+1

计算它们的差值：2+2*m*n - [(m+2)*n +1]= (m-2)*n+1

由上式看出，使用抽象工厂，系统中产生的类更少，假设m=5, n=5, 两个模式之间的类数量之差就有16个之多，想想以后继续扩展会使什么样子？

三、抽象工厂模式



图5 抽象工厂模式结构图

四、测试代码

转自：http://www.cnblogs.com/jiese/p/3156753.html

#ifndef _FACTORY_H_
#define _FACTORY_H_

#include "Define.h"

//AbstractFactory，工厂抽象基类，定义生产A类与B类产品的接口
class AbstractProductA;
class AbstractProductB;

Interface AbstractFactory
{
public:
virtual ~AbstractFactory()=0;
virtual AbstractProductA* CreateProductA()=0;
virtual AbstractProductB* CreateProductB()=0;
protected:
AbstractFactory();
};

//ConcreteFactory1，派生类，继承自AbstractFactory
//实现继承的接口，生产产品A和B的一种实现
class ConcreteFactory1:Implements AbstractFactory
{
public:
ConcreteFactory1();
~ConcreteFactory1();
virtual AbstractProductA* CreateProductA();
virtual AbstractProductB* CreateProductB();
};

//ConcreteFactory2，派生类，继承自AbstractFactory
//实现继承的接口，生产产品A和B的另一种实现
class ConcreteFactory2:Implements AbstractFactory
{
public:
ConcreteFactory2();
~ConcreteFactory2();
virtual AbstractProductA* CreateProductA();
virtual AbstractProductB* CreateProductB();
};

#endif

#ifndef _PRODUCT_H_
#define _PRODUCT_H_

#include "Define.h"

//抽象基类AbstractProductA，代表A类产品的抽象
Interface AbstractProductA
{
public:
virtual ~AbstractProductA()=0;
virtual void operation()=0;
protected:
AbstractProductA();//屏蔽构造函数
};

//派生类ProductA1，继承自AbstractProductA，A类产品的一种实现
class ProductA1 : Implements AbstractProductA
{
public:
ProductA1();
virtual void operation();
virtual ~ProductA1();
};

//派生类ProductA2，继承自AbstractProductA，A类产品的另一种实现
class ProductA2: Implements AbstractProductA
{
public:
ProductA2();
virtual void operation();
virtual ~ProductA2();
};

//抽象基类AbstractProductB，代表B类产品的抽象
Interface AbstractProductB
{
public:
virtual ~AbstractProductB()=0;
virtual void operation()=0;
protected:
AbstractProductB();//屏蔽构造函数
};

//派生类ProductB1，继承自AbstractProductB，B类产品的一种实现
class ProductB1:Implements AbstractProductB
{
public:
ProductB1();
virtual void operation();
virtual ~ProductB1();
};
//派生类ProductB2，继承自AbstractProductB，B类产品的另一种实现
class ProductB2:Implements AbstractProductB
{
public:
ProductB2();
virtual void operation();
virtual ~ProductB2();
};

#endif

#include "Factory.h"
#include "Product.h"
#include <iostream>

using namespace std;

AbstractFactory::AbstractFactory()
{
cout << "AbstractFactory..." << endl;
}

AbstractFactory::~AbstractFactory()
{
cout << "~AbstractFactory..." << endl;
}

ConcreteFactory1::ConcreteFactory1()
{
cout << "ConcreteFactory1..." << endl;
}

ConcreteFactory1::~ConcreteFactory1()
{
cout << "~ConcreteFactory1..." << endl;
}

AbstractProductA* ConcreteFactory1::CreateProductA()
{
return new ProductA1();
}

AbstractProductB* ConcreteFactory1::CreateProductB()
{
return new ProductB1();
}

ConcreteFactory2::ConcreteFactory2()
{
cout << "ConcreteFactory2..." << endl;
}

ConcreteFactory2::~ConcreteFactory2()
{
cout << "~ConcreteFactory2..." << endl;
}

AbstractProductA* ConcreteFactory2::CreateProductA()
{
return new ProductA2();
}

AbstractProductB* ConcreteFactory2::CreateProductB()
{
return new ProductB2();
}

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

using namespace std;

//AbstractProductA
AbstractProductA::AbstractProductA()
{
cout << "AbstractProductA..." << endl;
}

AbstractProductA::~AbstractProductA()
{
cout << "~AbstractProductA..." << endl;
}

//ProductA1
ProductA1::ProductA1()
{
cout << "ProductA1..." << endl;
}

ProductA1::~ProductA1()
{
cout << "~ProductA1..." << endl;
}

void ProductA1::operation()
{}

//ProductA2
ProductA2::ProductA2()
{
cout << "ProductA2..." << endl;
}

ProductA2::~ProductA2()
{
cout << "~ProductA2..." << endl;
}

void ProductA2::operation()
{}

//AbstractProductB
AbstractProductB::AbstractProductB()
{
cout << "AbstractProductB..." << endl;
}

AbstractProductB::~AbstractProductB()
{
cout << "~AbstractProductB..." << endl;
}

//ProductB1
ProductB1::ProductB1()
{
cout << "ProductB1..." << endl;
}

ProductB1::~ProductB1()
{
cout << "~ProductB1..." << endl;
}

void ProductB1::operation()
{}

//ProductB2
ProductB2::ProductB2()
{
cout << "ProductB2..." << endl;
}

ProductB2::~ProductB2()
{
cout << "~ProductB2..." << endl;
}

void ProductB2::operation()
{}

#include <QtCore/QCoreApplication>

#include <iostream>
#include "Factory.h"
#include "Product.h"

using namespace std;

int main()
{
AbstractFactory* fa1 = new ConcreteFactory1();
AbstractProductA* a1 = fa1->CreateProductA();
AbstractProductB* b1 = fa1->CreateProductB();

cout << endl;
AbstractFactory* fa2 = new ConcreteFactory2();
AbstractProductA* a2 = fa2->CreateProductA();
AbstractProductB* b2 = fa2->CreateProductB();

cout << endl;
delete fa1;
delete a1;
delete b1;

cout << endl;
delete fa2;
delete a2;
delete b2;

while(1);
return 0;
}