3.1 抽象工厂

好了，七月的第一篇博客正式标志着我的回归。六月已经过去，七月还是新的！

GOF的书真的不好懂，不知道是我的原因还是我的原因？好吧，既然不懂只能参考csdn博客了：http://blog.csdn.net/u010064842/article/details/9150921

 

简单抽象工厂模式

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

 

设计模式的学习一定要配合例子。比如说我吃厨师做的食物这件事。食物有很多种，可能是红烧肉，可能是清蒸鱼，每一种特定的食物都是一个具体的类。但是我不需要指定具体的类，我只需要指定一个接口——食物，其中包含了每个具体的食物类的共同的fuction。然后我只要指定厨师类帮我做特定食物类表示的食物就行了。

例子见图：

其实在上图中，厨师就是Factory，食物就是Product。抽象为抽象工厂模式见图：

代码实现：
//产品基类
#ifndef _PRODUCT_H
#define _PRODUCT_H

class Product
{
protected:
	Product(){}
public:
	virtual ~Product(){}
	virtual void function() = 0;
};

#endif

//具体产品A
#ifndef _CONCRETE_PRODUCT_A_H
#define _CONCRETE_PRODUCT_A_H
#include "Product.h"
#include <iostream>
using namespace std;
class ConcreteProductA:public Product
{
public:
	ConcreteProductA()
	{
		cout<<"创建产品A"<<endl;
	}
	virtual ~ConcreteProductA()
	{
		cout<<"释放产品A"<<endl;
	}

	virtual void function()
	{
		cout<<"这是产品A的基本功能"<<endl;
	}

};

#endif


//具体产品B
#ifndef _CONCRETE_PRODUCT_B_H
#define _CONCRETE_PRODUCT_B_H
#include "Product.h"
#include <iostream>
using namespace std;
class ConcreteProductB:public Product
{
public:
	ConcreteProductB()
	{
		cout<<"创建产品B"<<endl;
	}
	virtual ~ConcreteProductB()
	{
		cout<<"释放产品B"<<endl;
	}

	virtual void function()
	{
		cout<<"这是产品B的基本功能"<<endl;
	}

};

#endif

//工厂类：负责具体产品的创建，有两种方式实现产品的创建，
//I、创建不同的产品用不同的方法；II、创建不同产品用相同
//的方法，然后通过传递参数实现不同产品的创建。本实例中
//两种模式都给出了，大家自行分析。
#ifndef _SIMPLE_FACTORY_H
#define _SIMPLE_FACTORY_H

#include "Product.h"
#include "ConcreteProductA.h"
#include "ConcreteProductB.h"
class SimpleFactory
{
public:
	SimpleFactory(){}
	~SimpleFactory(){}
	Product *CreateProduct(int type)
	{
		Product *p = NULL;
		switch(type)
		{
		case 0:
			p = new ConcreteProductA();
			break;
		case 1:
			p = new ConcreteProductB();
			break;
		default:
			p = new ConcreteProductA();
			break;
		}
		return p;
	}

	Product *CreateProductA()
	{
		Product *p = new ConcreteProductA();
		return p;
	}

	Product *CreateProductB()
	{
		Product *p = new ConcreteProductB();
		return p;
	}

};
#endif

//客户端程序
#include <iostream>
#include "SimpleFactory.h"
#include "Product.h"
using namespace std;

int main(int argc, char **argv)
{
	SimpleFactory sf;
	Product *p = sf.CreateProductA();
	p->function();
	delete p;

	
	p = sf.CreateProduct(1);
	p->function();
	delete p;

	system("pause");
	return 0;
}

抽象工厂优点：将客户与类相分离，客户通过抽象接口操纵实例，产品的类名也在具体工厂的实现中被分离，不出现在客户代码中。

抽象工厂缺点：对修改不封闭，新增加产品您要修改工厂。违法了鼎鼎大名的开闭法则（OCP）。

 

抽象工厂模式的改进

在上面的代码中，如果新出来一个ProductC，那我首先需要创建一个ConcreteProductC类，然后在SimpleFactory类中增加对ConcreteProductC的调用，这需要修改SimpleFactory类，使得这个类不能封闭。

改进方法：将厨师类抽象为一个基类，再增加“做红烧肉的厨师类”，“做清蒸鱼的厨师类”等等，它们分别都继承厨师这个基类。现在来看这个模式发生了变化，结构中多了一个厨师的抽象，抽象并不具体的加工产品了，至于是炖汤还是炖鱼，是由这个抽象工厂的继承子类来实现，现在的模式也就变成工厂方法模式了。这样，如果我新出来一个菜，我不需要修改抽象的厨师类或者其他子类，我只需要增加一个做新菜的厨师类，继承于抽象的厨师类，就可以方便的增加一个菜了。

图示：

代码实现：
在原来的基础上增加：
//抽象的工厂类
#ifndef _FACTORY_H
#define _FACTORY_H

#include "Product.h"
class Factory
{
public:
	Factory(){}
	virtual ~Factory(){}
	virtual Product* CreateProduct(int type=0) = 0;
};
#endif

//具体工厂类：工厂基类的具体实现，由此类决定创建具体产品。
//这里ConcreteFactoryA 对于与图中的工厂实现，ConcreteFactoryB 
//对于与图中的新工厂。
#ifndef _CONCRETE_FACTORY_A_H
#define _CONCRETE_FACTORY_A_H

#include "Factory.h"
class ConcreteFactoryA: public Factory
{
public:
	ConcreteFactoryA(){}
	virtual ~ConcreteFactoryA(){}
	Product *CreateProduct(int type)
	{
		Product *p = NULL;
		switch (type)
		{
		case 0:
			p = new ConcreteProductA();
			break;
		case 1:
			p = new ConcreteProductB();
			break;
		default:
			p = new ConcreteProductA();
			break;
		}
		return p;
	}

};
#endif

//客户端程序
#include <iostream>
#include "SimpleFactory.h"
#include "Product.h"
#include "Factory.h"
#include "ConcreteFactoryA.h"
#include "ConcreteFactoryB.h"
using namespace std;

int main(int argc, char **argv)
{
	Factory *f = new ConcreteFactoryA();
	Product *p = f->CreateProduct(0);
	p->function();
	delete p;

	p = f->CreateProduct(1);
	p->function();
	delete p;
	delete f;

	f = new ConcreteFactoryB();
	p = f->CreateProduct();
	p->function();
	delete p;
	delete f;

	system("pause");
	return 0;
}

当然还可以继续改进，不多说了，见图：