设计模式那点事--策略模式

概念：

策略模式定义了一系列的算法，分别封装起来，让它们之间可以相互替换。此模式让算法的变化，不会影响到使用算法的客户。策略，实质上指的是算法。

例子：

一个鲜活简单的例子总能让人轻松地理解晦涩的概念。我们来看看一个关于汽车价格的策略模式。

我们知道，汽车的品牌和质量，决定了它的价格。就像宝马（BMW），法拉利（Ferrali）和奔驰（Benz）三辆汽车，它们的价格肯定是不一样的。那如果想要知道它的价格的话，可以询问销售人员等等。但是在计算机里，我们可不能直接问销售人员啊！

对于它们来说，虽然各自价格不同，是不同的算法，但是获取价格却是一种公共操作（策略模式要求的就是要封装变化的算法）。于是，可以创建一个抽象父类汽车类（Car），声明一个获取价格virtual GetPrice函数的接口。然后创建三个子类：BMW，Ferrali和Benz，分别继承于Car。通过继承关系，每个子类可以改写父类的GetPrice函数，然后在客户端中通过调用不同的汽车子类算法来获取子类汽车价格。

总结一下：

1、我们把父类Car当成是抽象策略类，提供了一个获取价格的GetPrice接口；

2、每种包含获取价格GetPrice的汽车类为具体策略类（每种牌子的车价格不一致，导致不同计算算法），要重写父类Car的GetPrice函数；

3、建立一个环境上下文类PriceContext，维护一个对父类Car对象（指针对象才能实现多态）的引用，最后给客户端调用具体的策略类对象。

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;
}

策略模式和简单工厂模式相结合：

简单工厂模式中，对象的动态创建判断放在了工厂类中。而基本的策略模式客户端还是要进行算法判断和对象创建。因此可模仿简单工厂，把算法的判断移到环境上下文类中，尽量减少客户端职责，降低耦合性。其中相对简单工厂模式来说，客户端中连基类都不出现，更加地隐藏算法的具体实现细节。

代码：

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、客户端必须知道所有的策略类，并自行决定使用哪一个策略类。这就意味着客户端必须理解这些算法的区别，以便适时选择恰当的算法类。换言之，策略模式只适用于客户端知道所有的算法或行为的情况。