设计模式之策略模式

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

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

一、什么是策略模式

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

　　　　　　　　　　　　　　　　策略模式的UML类图

二、策略模式用于解决什么问题

只要在分析问题中发现只要在不同时间应用不同的业务规则，就可以使用策略模式解决这种变化性。

三、策略模式的优缺点

优点：

1. 简化了单元测试，每个算法都有自己的类，可以通过自己的接口单独测试。

2. 避免使用多重条件判断语句，易于扩展。

缺点：

1. 每种具体的策略会增加一个新类，从而会增加系统需要维护的类的数量。

2. 需要由客户端选择具体实现的对象，并将其转给Strategy。

四、适用场景

1. 几个类的大部分算法相同，只有部分逻辑算法有所改动。

2. 有相似的行为，需要动态的由客户端决定使用哪一种。

五、举例说明

以商场打折为例：

首先给出一个父类和三个子类的具体代码：

//父类
class CashSuper
{
public:
    CashSuper(){}
    ~CashSuper(){}
    virtual double acceptCash(double money);
    
};

double CashSuper::acceptCash(double money)
{
    cout<<"CashSuper"<<endl;
    return 0.0;
}

//子类
class CashNormal : public CashSuper
{
public:
    CashNormal()
    {
        cout<<"CashNormal 构造函数.."<<endl;
    }
    ~CashNormal()
    {
        cout<<"CashNormal 析构函数.."<<endl;
    }
    double acceptCash(double money)
    {
        return money;
    }
};

//子类
class CashRabeta:public CashSuper
{
public:
    CashRabeta(double mRabeta)
    {
        cout<<"CashRabeta 构造函数.."<<endl;
        rabeta = mRabeta;
    }
    ~CashRabeta()
    {
        cout<<"CashRabeta 析构函数.."<<endl;
    }
    double acceptCash(double money)
    {
        return money * rabeta;
    }
private:
    double rabeta;
};

//子类
class CashReturn:public CashSuper
{
public:
    CashReturn(double mMoneyCondition,double mMoneyReturn)
    {
        cout<<"CashReturn 构造函数.."<<endl;
        moneyCondition = mMoneyCondition;
        moneyReturn = mMoneyReturn;
    }
    ~CashReturn()
    {
        cout<<"CashReturn 析构函数.."<<endl;
    }
    double acceptCash(double money)
    {
        if (money >= moneyCondition)
        {
            double retain = money - moneyCondition;
            double preferent = moneyCondition - moneyReturn;
            money = retain + preferent;
        }

        return money;
    }
private:
    double moneyCondition,moneyReturn;
};

然后给出Context的代码：

class CashContext
{
public:
    CashContext(CashSuper *mCS)
    {
        cs = mCS;
    }
    ~CashContext()
    {
        delete cs;
    }

    double getResult(double money)
    {
        if (cs == NULL)
        {
            cout<<"cs  is NULL"<<endl;
        }
        return cs->acceptCash(money);
    }
private:
    CashSuper *cs;
    
};

客户端调用的代码：

int main(int argc, char const *argv[])
{
    cout<<"Strategy .."<<endl;

    int type = 2;
    double money = 300;

    CashContext *context;
    switch(type)
    {
        case eCashNormal:
        context = new CashContext(new CashNormal());
        break;
        case eCashRabeta:
        context = new CashContext(new CashRabeta(0.8));
        break;

        case eCashReturn:
        context = new CashContext(new CashReturn(300,100));
        break;
    }
    double result = context->getResult(money);

    cout<<"result  :  "<<result<<endl;

    return 0;
}

从上面可以看出客户端决定了使用哪一种算法的对象，如果增添新的优惠活动时，对应的需要修改客户端的代码，这不能很好的遵循“开闭原则”。

我们可以将策略模式和简单工厂模式结合使用，代码如下：

//策略模式和简单工厂模式结合
class StrategyFactory
{
public:
    StrategyFactory(int type)
    {
        switch(type)
        {
            case eCashNormal:
            cs = new CashNormal();
            break;
            case eCashRabeta:
            cs = new CashRabeta(0.8);
            break;

            case eCashReturn:
            cs = new CashReturn(300,100);
            break;
        }
    }
    ~StrategyFactory(){
        delete cs;
    }

    double getResult(double money)
    {
        cout<<"strategy getResult.."<<endl;
        return cs->acceptCash(money);
    }
private:
    CashSuper *cs;
    
};

int main(int argc, char const *argv[])
{
    cout<<"Strategy .."<<endl;

    int type = 2;
    double money = 300;

    //策略模式和简单工厂模式结合使用
    StrategyFactory *factory = new StrategyFactory(type);
    double result = factory->getResult(money);

    cout<<"result  :  "<<result<<endl;

    return 0;
}

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

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

举个简单案例：

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

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