设计模式——简单工厂模式

设计模式——简单工厂模式#

---

都说代码之间的耦合度要低，要对扩展开放，修改封闭，但是在学习设计模式之前，这都是浮云。最近开始学习设计模式，跟大家分享一下。今天从运算器的角度，给大家带来的是——简单工厂模式。

首先看一下下面这个运算类。

enum OperatorType
{
	Plus,
	Subtract,
	Multiplication,
	Division
};
class Operator
{
	public static double GetResult(double numberA,double numberB,OperatorType operate)
	{
		double result 0;
		switch(operate)
		{
			case Plus:
			    return numberA + numberB;
			case Subtract:
			    return numberA - numberB;
			case Multiplication:
			    return numberA * numberB;
			case Division:
			    return numberA / numberB;
			default:
				cout<<"error"<<endl;
		}
	}
};

上面的这种写法，将运算当独作为一个类，能够避免在客户端进行逻辑判断，将逻辑部分与客户端分开了。但它有两个显著的缺点。

1. 但是它用到了面向对象三大特性，封装，继承，多态，中的封装。
2. 当除数为0时没有出错处理。

我们尝试着更改一下

enum OperatorType
{
	Plus,
	Subtract,
	Multiplication,
	Division
};
class Operator
{
protected:
	double numA;
	double numB;
public:
	virtual double GetResult() = 0;
};
class PlusOperator:public Operator
{
public:
	virtual double GetResult()
	{
		return numA + numB;
	}
};
class SubtractOperator
{
public:
	virtual double GetResult()
	{
		return numA - numB;
	}
};
class MultiplicationOperator
{
public:
	virtual double GetResult()
	{
		return numA * numB;
	}
};
class DivisionOperator
{
public:
	virtual double GetResult()
	{
		if(0 == numB)
		{
			cout<<"error"<<endl;
			return 0;
		}
		return numA / numB;
	}
};

如上，当我们需要用到加法的时候，只需要使用PlusOperator类即可。这相当于客户端还是需要进行一定的逻辑判断。我们可以将这部分逻辑使用一个类OperationFactory统一管理这部分逻辑，并把这个类称为简单工厂类。

//简单工厂类
class OperationFactory
{
	public static Operator* CreateOperator(OperatorType operate)
	{
		switch(operate)
		{
			case Plus:
			    return new PlusOperator();
			case Subtract:
			    return new SubtractOperator();
			case Multiplication:
			    return new MultiplicationOperator();
			case Division:
			    return new DivisionOperator();
			default:
				cout<<"error"<<endl;
		}
	}
};
void main()
{
	OperationFactory factory;
	Operator* operPlus = OperationFactory::CreateOperator(Plus);
	operPlus->numA = 1;
	operPlus->numB = 1;
	cout<<operPlus->GetResult()<<endl;
	Operator *operSub = OperationFactory::CreateOperator(Subtract);
	operSub->numA = 1;
	operSub->numB = 1;
	cout<<operSub->GetResult()<<endl;
}

在上面的客户端中我们可以发现，我们只需要知道运算操作的基类于工厂类，就能够方便地进行一系列的运算。而当我们需要增加一个运算的时候，只需要增加一个类与增加工厂类的一个case分支。我们将这种“使用一个工厂类来统一管理并产生实例的方法叫做简单工厂模式"。

总结#

优点###

1. 将逻辑处理从客户端分离，减少了代码的耦合度，从而让代码修改起来更方便。
2. 易于拓展，当需要增加新的运算时，只需要添加新的类与增加case语句即可。

缺点###

1. 当我们需要增加新的功能时，需要修改原来的代码。一定程度上违反了面向对象设计的“对修改封闭，对扩展开发”原则。