【设计模式】简单工厂模式

一，概念

        从设计模式的类型上来说，简单工厂模式是属于创建型模式，又叫做静态工厂方法（StaticFactory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

二，实例

        请用C++、Java、C#任意一种面向对象语言实现一个计算器控制台程序

三，菜鸟实现

#include <iostream>
#include <exception>

using namespace std;

int main()
{
	try{
		
		string a,b;
		char op;
		int result; 
		cout<<"请输入数字A"<<endl;
		cin>>a;
		cout<<"请输入运算符（+，-，*，/）"<<endl;
		cin>>op;
		cout<<"请输入数字B"<<endl;
		cin>>b;
		int A=atoi(a.c_str());
		int B=atoi(b.c_str());
		
		switch(op)
		{
			case '+':result=A+B;break;
			case '-':result=A-B;break;
			case '*':result=A*B;break;
			case '/':
			       if(B==0)
			          result=-9999;
                   else 
			          result=A/B;
	                  break; 
            default:result =-9999;
		}	
		
		cout<<"result="<<result<<endl;
	}
	catch(exception &e)
	{
		cout<<"Exception:"<<e.what()<<endl;	
	}
	
	return 0;
}

分析：程序实现还算可以，注意到了： 1）除数为0的判断，和异常的检查

                                                                     2）switch的应用，在C/C++中switch之接受 char 和 int 类型。其他的类型只能用if

存在的问题： 1）首先没有按照面向对象的设计方式实现。

                         2）不容易维护

                         3）不容易复用：控制台改成图形界面？只能复制代码，然后更改代码。不能直接调用代码类

                         4）不容易扩展：如果要添加 sqrt( ) 开方？如何实现？

                         5）灵活性不好：操作类和界面类没有分开。

解决办法：通过面向对象的三大技术封装、继承和多态

首先应用封装，让业务逻辑、界面逻辑分开，降低耦合度。

菜鸟进阶一：

#include <iostream>
#include <exception>

using namespace std;
class Operation
{
public:
 static int GetResult(int A,int B,char op) //static 静态类，所有对象共享一个方法 
{
	int result;
	switch(op)
		{
			case '+':result=A+B;break;
			case '-':result=A-B;break;
			case '*':result=A*B;break;
			case '/':
			       if(B==0)
			          result=-9999;
                   else 
			          result=A/B;
	                  break; 
            default:result =-9999;
		}	
		
	return result;
}
	
} ;

int main()
{
	Operation  operation;
	try{
		
		string a,b;
		char op;
		int result; 
		cout<<"请输入数字A"<<endl;
		cin>>a;
		cout<<"请输入运算符（+，-，*，/）"<<endl;
		cin>>op;
		cout<<"请输入数字B"<<endl;
		cin>>b;
		int A=atoi(a.c_str());
		int B=atoi(b.c_str());
		
		result = operation.GetResult(A,B,op);
		
		cout<<"result="<<result<<endl;
	}
	catch(exception &e)
	{
		cout<<"Exception:"<<e.what()<<endl;	
	}
	
	return 0;
}

试想，如果想增加一个sqrt()。是不是还是要阅读源代码，然后在相应位置添加实现sqrt()的源代码，才可以实现。

如何才能实现松耦合呢？

采用面向对象技术的继承就可以。

菜鸟进阶二

#include <iostream>
#include <exception>

using namespace std;

class Operation //操作运算基类 
{
public:
	Operation(){}
	~Operation(){}
public:
	double numberA;
	double numberB;
	char operate ;
public:
	void setNumberA(double number)//设置第一个操作数 
	{
		numberA = number;
	}
	double getNumberA() //获取第一个操作数 
	{
		return numberA;
	}

	void setNumberB(double number)
	{
		numberB = number;
	}
	double getNumberB()
	{
		return numberB;
	}

public:
	virtual double GetResult() //虚拟类 
	{
		double result = 0;
		return result;
	}
};


class OperationAdd :public Operation
{
public:
	OperationAdd(void){}
	~OperationAdd(void){}
public:
	double GetResult()  //重载基类中方法，实现加法 
	{
		double result = 0;
		result = numberA + numberB;
		return result;
	}
};

class OperationSub :public Operation
{
public:
	OperationSub(void){}

	~OperationSub(void){}
public:
	double GetResult()//重载基类中方法，实现减法 
	{
		double result = 0;
		result =numberA - numberB;
		return result;
	}

};

class OperationMul :public Operation
{
public:
	OperationMul(void){}
	~OperationMul(void){}
public:
	double GetResult()//重载基类中方法，实现乘法 
	{
		double result = 0;
		result =numberA * numberB;
		return result;
	}
};


class OperationDiv :public Operation
{
public:
	OperationDiv(void){}

	~OperationDiv(void){}
public:
	double GetResult()//重载基类中方法，实现除法 
	{
		double result = 0;
		result =numberA / numberB;
		return result;
	}
};

class OperationFactory//运算工厂类 
{
public:
	OperationFactory(){}
	~OperationFactory(){}
public:
	Operation *oper; //运算基类 可以生成不同运算的子类（+，-，*，/） 
public :
	Operation *createOperate(char operate) //返回类型是指针 
	{
		switch (operate)
		{
		case '+':
			{
				oper = new OperationAdd();
				break;
			}
		case '-':
			{
				oper = new OperationSub();
				break;
			}
		case '*':
			{
				oper = new OperationMul();
				break;
			}
		case '/':
			{
				oper = new OperationDiv();
				break;
			}
		}

		return oper;
	}
};

int main()
{
	double strNumberA,strNumberB, result;
	char  strOperation;
	Operation *oper;
	OperationFactory factory;
	oper = factory.createOperate('*');
	oper->setNumberA(2);
	oper->setNumberB(4);
	result = oper->GetResult(); //调用的运算工厂返回的，各个操作运算符生成的对象
	
	cout<<"result="<<result<<endl; 
	return 0;
}

整个程序结构说明：

class Operation                                       //操作运算基类 ，包含运算所必须的操作运算符和操作数，提供设定操作数和返回操作数方法

class OperationAdd :public Operation  //加法运算子类，设定运算结果

class OperationSub :public Operation  //减法运算子类

class OperationMul :public Operation  //乘法运算子类

class OperationDiv :public Operation  //除法运算子类

class OperationFactory                         //运算工厂类 ，负责生成各个操作运算符的类。

【注意】Operation *createOperate(char operate) //返回类型是指针

主要构成结构为： 操作运算符基类：定义操作必须的运算符和操作数，提供设定操作数和返回操作数方法

                                 四种运算子类：继承操作运算符基类，并实现每种运算符下的结果

                                 运算工厂：根据传递参数，生成不同运算符子类返回相应结果

                                 客户端：建立操作符基类，根据工厂生成子类，然后返回结果。