概念:
策略模式定义了一系列的算法,分别封装起来,让它们之间能够相互替换。
此模式让算法的变化,不会影响到使用算法的客户。策略,实质上指的是算法。
样例:
一个鲜活简单的样例总能让人轻松地理解晦涩的概念。
我们来看看一个关于汽车价格的策略模式。
我们知道。汽车的品牌和质量。决定了它的价格。
就像宝马(BMW)。法拉利(Ferrali)和奔驰(Benz)三辆汽车,它们的价格肯定是不一样的。那假设想要知道它的价格的话。能够询问销售人员等等。可是在计算机里,我们可不能直接问销售人员啊!
对于它们来说。尽管各自价格不同。是不同的算法。可是获取价格却是一种公共操作(策略模式要求的就是要封装变化的算法)。于是。能够创建一个抽象父类汽车类(Car),声明一个获取价格virtual GetPrice函数的接口。
然后创建三个子类:BMW,Ferrali和Benz,分别继承于Car。通过继承关系,每一个子类能够改写父类的GetPrice函数,然后在client中通过调用不同的汽车子类算法来获取子类汽车价格。
总结一下:
1、我们把父类Car当成是抽象策略类,提供了一个获取价格的GetPrice接口;
2、每种包括获取价格GetPrice的汽车类为详细策略类(每种牌子的车价格不一致,导致不同计算算法)。要重写父类Car的GetPrice函数;
3、建立一个环境上下文类PriceContext,维护一个对父类Car对象(指针对象才干实现多态)的引用。最后给client调用详细的策略类对象。
UML图:
代码:
#include <iostream>
using namespace std;
class Car
{
public:
float m_fPrice;
public:
virtual float GetPrice()
{
return m_fPrice*1;
}
};
class BMW:public Car
{
public:
float GetPrice()
{
return m_fPrice*3;
}
};
class Ferrali:public Car
{
public:
float GetPrice()
{
return m_fPrice*11;
}
};
class Benz:public Car
{
public:
float GetPrice()
{
return m_fPrice*6;
}
};
class PriceContext
{
public:
int m_iFlag;
private:
Car* m_cCar;
public:
PriceContext(Car* cCar):m_cCar(cCar)
{
//this->m_cCar = cCar;
}
float GetPriceContext()
{
m_cCar->m_fPrice = 10000;
return(m_cCar->GetPrice());
}
};
int main()
{
float fPrice=0.0;
int iTag=0;
cout<<"----策略模式開始----"<<endl;
cout<<"BMW:1,Ferrali:2,Benz:3"<<endl;
cout<<"请输入您想要查询的汽车价格:";
cin>>iTag;
PriceContext* priceContext;
switch (iTag)
{
case 1:
priceContext = new PriceContext(new BMW);
break;
case 2:
priceContext = new PriceContext(new Ferrali);
break;
case 3:
priceContext = new PriceContext(new Benz);
break;
default:
priceContext = new PriceContext(new Car);
break;
}
fPrice = priceContext->GetPriceContext();
delete priceContext;
priceContext = NULL;
cout<<"价格为:"<<fPrice<<endl;
cout<<"----策略模式结束----"<<endl;
return 1;
}
策略模式和简单工厂模式相结合:
简单工厂模式中。对象的动态创建推断放在了工厂类中。
而主要的策略模式client还是要进行算法推断和对象创建。
因此可模仿简单工厂,把算法的推断移到环境上下文类中,尽量降低client职责,降低耦合性。当中相对简单工厂模式来说,client中连基类都不出现,更加地隐藏算法的详细实现细节。
代码:
class PriceContext
{
public:
int m_iFlag;
private:
Car* m_cCar;
public:
PriceContext(int iFlag) //构造中不再穿对象。传标识
{
switch (iFlag)
{
case 1:
m_cCar = new BMW;
break;
case 2:
m_cCar = new Ferrali;
break;
case 3:
m_cCar = new Benz;
break;
default:
m_cCar = new Car;
break;
}
}
float GetPriceContext()
{
m_cCar->m_fPrice = 10000;
return(m_cCar->GetPrice());
}
};
int main()
{
float fPrice=0.0;
int iTag=0;
cout<<"----策略模式開始----"<<endl;
cout<<"BMW:1,Ferrali:2,Benz:3"<<endl;
cout<<"请输入您想要查询的汽车价格:";
cin>>iTag;
PriceContext* priceContext = new PriceContext(iTag);
fPrice = priceContext->GetPriceContext();
delete priceContext;
priceContext = NULL;
cout<<"价格为:"<<fPrice<<endl;
cout<<"----策略模式结束----"<<endl;
return 1;
}
总结:
1、策略模式定义了一系列的算法。从概念上看,全部算法完毕的都是同样的操作,仅仅是表现行为不同。通过同样的方式调用全部的算法(使用多态),降低了算法类与使用算法类之间的耦合。
2、对客户隐藏详细策略(算法)的实现细节,彼此全然独立;
3、策略模式简化了单元測试,每一个算法都有自己的类。能够通过自己的接口单独測试;
4、client必须知道全部的策略类,并自行决定使用哪一个策略类。这就意味着client必须理解这些算法的差别,以便适时选择恰当的算法类。换言之,策略模式仅仅适用于client知道全部的算法或行为的情况。