设计模式之策略模式

近期看同事写的代码,看的过程中很是吃力。原因是代码中用了几种设计模式,而我对常用的几种设计模式不熟悉,所以导致看别人调来调去的代码很费劲。正好这几天工作不是特别忙,抓紧时间恶补下相关知识(我看的是《大话设计模式》这本书)。

今天介绍的是策略模式,分为如下四个部分分析。

一、什么是策略模式

策略模式定义了算法家族,分别封装起来,使它们之间可以相互替换,当算法发生变化时,不会影响调用该算法的外部客户。

                策略模式的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 }

注意:简单工厂模式与策略模式之间的区别很小,都是使用了多态和继承。

简单工厂模式只是解决了对象的创建问题,而策略模式的目的是确定使用哪种策略。

举个简单案例:

简单工厂模式:去餐厅点餐,你点了一份油焖大虾,作为用户,你不需要知道这道菜是用了多少油,多少盐等等,你只需要等上几分钟就可得到一份美味的油焖大虾。

策略模式:同样去餐厅点了一份油焖大虾,老板让你自己动手去做。这时候就要自己考虑用多少只虾,多少油,多少盐等,该按照怎么的流程做出最终的油焖大虾。

posted @ 2017-05-16 15:00  bky2016  阅读(281)  评论(0编辑  收藏  举报