1.简单工厂模式
先看示例代码,然后结合例子说明问题,理论联系实例是初学者入门的最好方法
下面是实现一个简单计算器的小例子
Operation.h
#include <iostream>
using namespace std;
class Operation{
private:
double _numberA;
double _numberB;
public:
double getNumberA(){
return _numberA;
}
void setNumberA(double value){
_numberA=value;
}
double getNumberB(){
return _numberB;
}
void setNumberB(double value){
_numberB=value;
}
virtual double GetResult(){
double result = 0;
return result;
}
};
inheritOper.h
#include "Operation.h"
class OperationAdd:public Operation{
double GetResult(){
double result = getNumberA()+getNumberB();
return result;
}
};
class OperationSub:public Operation{
double GetResult(){
double result = getNumberA()-getNumberB();
return result;
}
};
class OperationMul:public Operation{
double GetResult(){
double result = getNumberA()*getNumberB();
return result;
}
};
class OperationDiv:public Operation{
double GetResult(){
if(getNumberB()==0){
cout<<"除数不能为0"<<endl;
exit(-1);
}
double result = getNumberA()/getNumberB();
return result;
}
};
OperationFactory.h
#include "inheritOper.h"
class OperationFactory{
public:
Operation* createOperate(char operate){
Operation *oper;
switch(operate){
case '+':
oper = new OperationAdd();
break;
case '-':
oper = new OperationSub();
break;
case '*':
oper = new OperationMul();
break;
case '/':
oper = new OperationDiv();
break;
}
return oper;
}
};
main.cpp
#include "OperationFactory.h"
void main(){
OperationFactory a;
Operation *oper=a.createOperate('*');
oper->setNumberA(3);
oper->setNumberB(4);
double ret=oper->GetResult();
cout<<ret<<endl;
}
从上面的例子可以看出,具体的运算类对象创建被封装在工厂类OperationFactory 中,其实例化也延迟到了这个类中,这个例子中也体现了继承和多态
Factory模式的两个最重要的功能:
1)定义创建对象的接口,封装了对象的创建;
2)使得具体化类的工作延迟到了子类中。
简单工厂模式主要用于在工厂中实例化对象,新添加类时,不会影响以前的代码。核心思想是用一个工厂来根据输入的条件产生不同的类,然后根据不同类的virtual函数得到不同的结果,适用于不同情况创建不同的类时,缺点是客户端需要知道基类和工厂类,耦合性差
现在想来,lucene/solr在处理分词时,就用到了工厂模式,当时不知道这些分词类为什么用factory来结尾,原来是工厂模式的一种应用,从这里足以体现设计模式在框架中的应用。
2.策略模式
strategy.h
#include <iostream>
using namespace std;
class strategy{
public:
virtual void testInterface(){};
};
class strategyA:public strategy{
void testInterface(){
cout<<"test A"<<endl;
}
};
class strategyB:public strategy{
void testInterface(){
cout<<"test B"<<endl;
}
};
class strategyC:public strategy{
void testInterface(){
cout<<"test C"<<endl;
}
};
context.h
#include "strategy.h"
class context{
private:
strategy *stra;
public:
context(strategy *str){
stra=str;
}
void contextInterface(){
stra->testInterface();
}
};
main.cpp
#include "context.h"
void main(){
context *cont=new context(new strategyB());
cont->contextInterface();
}
从例子中可以看到,将子类中的相同方法testInterface放在了context中调用。策略模式是一种定义一系列算法的方法,从概念上来看,所有这些算法完成的都是相同的工作,只是实现不同,它可以以相同的方式调用所有的算法,减少了各种算法类与使用算法类之间的耦合
策略模式是用来封装算法的,只要在分析过程中听到需要在不同时间应用不同的业务规则,就可以考虑使用策略模式处理这种变化的可能性
策略模式适合类中的成员以方法为主,算法经常变动,简化了单元测试,因为每个算法都有自己的类,可以通过自己的接口单独测试。策略模式和简单工厂模式基本相同,但简单工厂模式只能解决对象创建问题,对于经常变动的算法应使用策略模式。策略模式的缺点是客户端要做出判断
策略模式与简单工厂模式结合后,客户端只需访问context类,而不用知道其它任何类信息,实现了低耦合