设计模式-工厂方法模式

工厂方法模式的核心精神是封装类中不变的部分，提取其中个性化善变的部分为独立类，通过依赖达到解耦、复用和方便后期维护拓展的目的。当前模式与简单工厂模式的不同是，当前模式使类的实例化延迟到其子类，并且相比简单工厂模式本模式更加符合开放-封闭原则。

 

工厂方法模式定义一个创建产品对象的接口，将实际创建工作推迟到子类中。相比于简单工厂核心工厂不再负责产品的创建，更好的体现依赖接口而不是依赖细节编程的理念，如此的抽象化保证工厂方法模式在引进新产品时可以不修改具体的工厂角色，只需要添加新的实现类。

主要分为四个角色：抽象工厂，工厂方法接口；具体工厂，实现抽象工厂接口的具体工厂类，完成具体工厂的创建。抽象产品，产品对象接口；具体产品，实现抽象产品角色所定义的接口。

#include "stdafx.h"
#include <string>
#include <iostream>

using namespace std;

//方法类接口
class Operation
{
public:
	explicit Operation(){}
	virtual ~Operation(){}

	virtual float GetResult(){ return 0;}

	void FNumA(float tmpA){m_NumA = tmpA;}
	void FNumB(float tmpB){m_NumB = tmpB;}

protected:
	float m_NumA;
	float m_NumB;
};

//具体类加法类
class OperationAdd : public Operation
{
public:
	explicit OperationAdd(){}
	virtual ~OperationAdd(){}

	float GetResult()
	{
		return m_NumA + m_NumB;
	}
};
//具体类,减法类
class OperationSub : public Operation
{
public:
	explicit OperationSub(){}
	virtual ~OperationSub(){}

	float GetResult()
	{
		return m_NumA - m_NumB;
	}
};

//工厂类接口
class IFactory
{
public:
	explicit IFactory(){}
	virtual ~IFactory(){}

	virtual Operation * CreatOperation() = 0;
};

//加法工厂
class AddFactory : public IFactory
{
public:
	explicit AddFactory(){}
	virtual ~AddFactory(){}

	virtual Operation * CreatOperation()
	{
		return new OperationAdd;
	}
};

//减法工厂
class SubFactory : public IFactory
{
public:
	explicit SubFactory(){}
	virtual ~SubFactory(){}

	virtual Operation * CreatOperation()
	{
		return new OperationSub;
	}
};

void main()
{
    IFactory *opF = new AddFactory;

	Operation * OP = opF->CreatOperation();//创建加法工厂

	OP->FNumA(8);
	OP->FNumB(9);

	float yu = OP->GetResult();
}

关于应用，来自百度百科

工厂方法经常用在以下两种情况中:

第一种情况是对于某个产品，调用者清楚地知道应该使用哪个具体工厂服务，实例化该具体工厂，生产出具体的产品来。Java Collection中的iterator() 方法即属于这种情况。

第二种情况，只是需要一种产品，而不想知道也不需要知道究竟是哪个工厂为生产的，即最终选用哪个具体工厂的决定权在生产者一方，它们根据当前系统的情况来实例化一个具体的工厂返回给使用者，而这个决策过程这对于使用者来说是透明的。

关于简单工厂的解释见：http://blog.csdn.net/sdausxc/article/details/51595231