设计模式实现（五）--- 工厂方法模式（Factory Method）

简单工厂模式与工厂方法模式之间的区别：

简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。但是在需要为工厂新加功能的时候，就不得不更改工厂中的代码，增加实例化该功能类的判断条件。

违背了开放-封闭原则（对外扩展开放，对内修改封闭）。

以计算器实现为例

代码实现如下：

#include <stdio.h>
//方法类
class Operations
{
public:
	int num1,num2;
public:
	virtual int GetReasult() = 0;
};
//方法子类
class OperationAdd : public Operations
{
public:
	int GetReasult()
	{
		return num1 + num2;
	}
};
class OperationSub : public Operations
{
public:
	int GetReasult()
	{
		return num1 - num2;
	}
};
class OperationMul : public Operations
{
public:
	int GetReasult()
	{
		return num1 * num2;
	}
};
class OperationDiv : public Operations
{
public:
	int GetReasult()
	{
		if(num2 != 0)
			return num1 * num2;
		return 0;
	}
};
//工厂类
class OperationFactory
{
public:
	Operations * createOperation(char in)
	{
		Operations *temp = NULL;
		switch(in)
		{
		case '+':
			temp = new OperationAdd();
			break;
		case '-':
			temp = new OperationSub();
			break;
		case '*':
			temp = new OperationMul();
			break;
		case '/':
			temp = new OperationDiv();
			break;
		default:
			break;
		}
		return temp;
	}
};

//客户端部分
int main()
{
	Operations *oper = NULL;
	OperationFactory operFactory;

	oper = operFactory.createOperation('+');
	oper->num1 = 10;
	oper->num2 = 12;

	int res = oper->GetReasult();

	return 1;
}

工厂方法模式：

工厂方法模式（Factory Method）:定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法是用一个类的实例化延迟其子类。
工厂模式在需要新加功能的时候不需要修改工厂类中的方法，只需要创建功能子类就可以了。将判断具体实例化哪个类放在了客户端进行判断。

工厂方法模式实现时，客户端需要决定实例化哪一个工厂来实现运算类，选择判断的问题还是存在的，也就是说，工厂方法把简单工作的内部逻辑判断移到了客户端代码来进行。你想要加功能，本来是改工厂类的，而现在是修改客户端。

#include <stdio.h>
//方法类
class Operations
{
public:
	int num1,num2;
public:
	virtual int GetReasult() = 0;
};
//方法子类
class OperationAdd : public Operations
{
public:
	int GetReasult()
	{
		return num1 + num2;
	}
};
class OperationSub : public Operations
{
public:
	int GetReasult()
	{
		return num1 - num2;
	}
};
class OperationMul : public Operations
{
public:
	int GetReasult()
	{
		return num1 * num2;
	}
};
class OperationDiv : public Operations
{
public:
	int GetReasult()
	{
		if(num2 != 0)
			return num1 * num2;
		return 0;
	}
};
class Factory
{
public:
	virtual Operations *CreateOper() = 0;
};
class FactoryAdd : public Factory
{
public:
	Operations *CreateOper()
	{
		OperationAdd *oper = new OperationAdd();
		return oper;
	}
};
class FactorySub : public Factory
{
public:
	Operations *CreateOper()
	{
		OperationSub *oper = new OperationSub();
		return oper;
	}
};
class FactoryMul : public Factory
{
public:
	Operations *CreateOper()
	{
		OperationMul *oper = new OperationMul();
		return oper;
	}
};
class FactoryDiv : public Factory
{
public:
	Operations *CreateOper()
	{
		OperationDiv *oper = new OperationDiv();
		return oper;
	}
};
int main()
{
	Factory *fac = (Factory *)new FactoryAdd();
	Operations *oper = fac->CreateOper();
	oper->num1 = 10;
	oper->num2 = 12;
	int res = oper->GetReasult();
	return 1;
}