近期看同事写的代码，看的过程中很是吃力。原因是代码中用了几种设计模式，而我对常用的几种设计模式不熟悉，所以导致看别人调来调去的代码很费劲。正好这几天工作不是特别忙，抓紧时间恶补下相关知识（我看的是《大话设计模式》这本书）。
今天介绍的是策略模式，分为如下四个部分分析。
一、什么是策略模式
策略模式定义了算法家族，分别封装起来，使它们之间可以相互替换，当算法发生变化时，不会影响调用该算法的外部客户。
策略模式的UML类图
二、策略模式用于解决什么问题
只要在分析问题中发现只要在不同时间应用不同的业务规则，就可以使用策略模式解决这种变化性。
三、策略模式的优缺点
优点：
1. 简化了单元测试，每个算法都有自己的类，可以通过自己的接口单独测试。
2. 避免使用多重条件判断语句，易于扩展。
缺点：
1. 每种具体的策略会增加一个新类，从而会增加系统需要维护的类的数量。
2. 需要由客户端选择具体实现的对象，并将其转给Strategy。
四、适用场景
1. 几个类的大部分算法相同，只有部分逻辑算法有所改动。
2. 有相似的行为，需要动态的由客户端决定使用哪一种。
五、举例说明
以商场打折为例：
首先给出一个父类和三个子类的具体代码：
1 //父类 2 class CashSuper 3 { 4 public: 5 CashSuper(){} 6 ~CashSuper(){} 7 virtual double acceptCash(double money); 8 9 }; 10 11 double CashSuper::acceptCash(double money) 12 { 13 cout<<"CashSuper"<<endl; 14 return 0.0; 15 } 16 17 //子类 18 class CashNormal : public CashSuper 19 { 20 public: 21 CashNormal() 22 { 23 cout<<"CashNormal 构造函数.."<<endl; 24 } 25 ~CashNormal() 26 { 27 cout<<"CashNormal 析构函数.."<<endl; 28 } 29 double acceptCash(double money) 30 { 31 return money; 32 } 33 }; 34 35 //子类 36 class CashRabeta:public CashSuper 37 { 38 public: 39 CashRabeta(double mRabeta) 40 { 41 cout<<"CashRabeta 构造函数.."<<endl; 42 rabeta = mRabeta; 43 } 44 ~CashRabeta() 45 { 46 cout<<"CashRabeta 析构函数.."<<endl; 47 } 48 double acceptCash(double money) 49 { 50 return money * rabeta; 51 } 52 private: 53 double rabeta; 54 }; 55 56 //子类 57 class CashReturn:public CashSuper 58 { 59 public: 60 CashReturn(double mMoneyCondition,double mMoneyReturn) 61 { 62 cout<<"CashReturn 构造函数.."<<endl; 63 moneyCondition = mMoneyCondition; 64 moneyReturn = mMoneyReturn; 65 } 66 ~CashReturn() 67 { 68 cout<<"CashReturn 析构函数.."<<endl; 69 } 70 double acceptCash(double money) 71 { 72 if (money >= moneyCondition) 73 { 74 double retain = money - moneyCondition; 75 double preferent = moneyCondition - moneyReturn; 76 money = retain + preferent; 77 } 78 79 return money; 80 } 81 private: 82 double moneyCondition,moneyReturn; 83 };
然后给出Context的代码：
1 class CashContext 2 { 3 public: 4 CashContext(CashSuper *mCS) 5 { 6 cs = mCS; 7 } 8 ~CashContext() 9 { 10 delete cs; 11 } 12 13 double getResult(double money) 14 { 15 if (cs == NULL) 16 { 17 cout<<"cs is NULL"<<endl; 18 } 19 return cs->acceptCash(money); 20 } 21 private: 22 CashSuper *cs; 23 24 };
客户端调用的代码：
1 int main(int argc, char const *argv[]) 2 { 3 cout<<"Strategy .."<<endl; 4 5 int type = 2; 6 double money = 300; 7 8 CashContext *context; 9 switch(type) 10 { 11 case eCashNormal: 12 context = new CashContext(new CashNormal()); 13 break; 14 case eCashRabeta: 15 context = new CashContext(new CashRabeta(0.8)); 16 break; 17 18 case eCashReturn: 19 context = new CashContext(new CashReturn(300,100)); 20 break; 21 } 22 double result = context->getResult(money); 23 24 cout<<"result : "<<result<<endl; 25 26 return 0; 27 }
从上面可以看出客户端决定了使用哪一种算法的对象，如果增添新的优惠活动时，对应的需要修改客户端的代码，这不能很好的遵循“开闭原则”。
我们可以将策略模式和简单工厂模式结合使用，代码如下：
1 //策略模式和简单工厂模式结合 2 class StrategyFactory 3 { 4 public: 5 StrategyFactory(int type) 6 { 7 switch(type) 8 { 9 case eCashNormal: 10 cs = new CashNormal(); 11 break; 12 case eCashRabeta: 13 cs = new CashRabeta(0.8); 14 break; 15 16 case eCashReturn: 17 cs = new CashReturn(300,100); 18 break; 19 } 20 } 21 ~StrategyFactory(){ 22 delete cs; 23 } 24 25 double getResult(double money) 26 { 27 cout<<"strategy getResult.."<<endl; 28 return cs->acceptCash(money); 29 } 30 private: 31 CashSuper *cs; 32 33 }; 34 35 int main(int argc, char const *argv[]) 36 { 37 cout<<"Strategy .."<<endl; 38 39 int type = 2; 40 double money = 300; 41 42 //策略模式和简单工厂模式结合使用 43 StrategyFactory *factory = new StrategyFactory(type); 44 double result = factory->getResult(money); 45 46 cout<<"result : "<<result<<endl; 47 48 return 0; 49 }
注意：简单工厂模式与策略模式之间的区别很小，都是使用了多态和继承。
简单工厂模式只是解决了对象的创建问题，而策略模式的目的是确定使用哪种策略。
举个简单案例：
简单工厂模式：去餐厅点餐，你点了一份油焖大虾，作为用户，你不需要知道这道菜是用了多少油，多少盐等等，你只需要等上几分钟就可得到一份美味的油焖大虾。
策略模式：同样去餐厅点了一份油焖大虾，老板让你自己动手去做。这时候就要自己考虑用多少只虾，多少油，多少盐等，该按照怎么的流程做出最终的油焖大虾。