一,概念
从设计模式的类型上来说,简单工厂模式是属于创建型模式,又叫做静态工厂方法(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;
}
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) //返回类型是指针
主要构成结构为: 操作运算符基类:定义操作必须的运算符和操作数,提供设定操作数和返回操作数方法
四种运算子类:继承操作运算符基类,并实现每种运算符下的结果
运算工厂:根据传递参数,生成不同运算符子类返回相应结果
客户端:建立操作符基类,根据工厂生成子类,然后返回结果。