【设计模式】——策略模式

　　面向对象的编程，并不是类越多越好，类的划分是为了封装，但分类的基础是抽象，具有相同属性和功能的对象的抽象集合才是类。

　　在说策略模式之前，我们想用简单工厂模式来实现商场收银程序

#include <iostream>
using namespace std;
//现金收费抽象类
class CashSuper
{
public:
    virtual double acceptCash(double money)=0;
};
//正常收费子类
class CashNormal:public CashSuper
{
public:
    double acceptCash(double money)
    {
        return money;
    }
};
//打折收费子类
class CashRebate:public CashSuper
{
private:
    double moneyRebate;
public:
    CashRebate(double moneyRebate)
    {
        this->moneyRebate=moneyRebate;
    }
    double acceptCash(double money)
    {
        return money*moneyRebate;
    }
};
//返利收费子类
class CashReturn:public CashSuper
{
private:
    double moneyCondition;
    double moneyReturn;
public:
    CashReturn(double moneyCondition,double moneyReturn)
    {
        this->moneyCondition=moneyCondition;
        this->moneyReturn=moneyReturn;
    }
    double acceptCash(double money)
    {
        double result=money;
        if(money>=moneyCondition)
            result=money-(money/moneyCondition)*moneyReturn;
        return result;
    }
};
//收费对象生成工厂
class CashFactory
{
public:
    static CashSuper *createCashAccept(int type)
    {
        CashSuper *cs=NULL;
        switch(type)
        {
        case 1://正常模式
            cs=new CashNormal();
            break;
        case 2://打八折
            cs=new CashRebate(0.8);
            break;
        case 3:
            cs=new CashReturn(300,100);
            break;
        default:
            break;
        }
        return cs;
    }
};
int main()
{
    double total=0;
    CashFactory *cf=new CashFactory();
    CashSuper *cs=cf->createCashAccept(2);
    double totalprices=0;
    totalprices=cs->acceptCash(300);
    total+=totalprices;
    cout << "total=" << total << endl;
    return 0;
}

　　简单工厂模式只是解决对象的创建问题，而且由于工厂本身包括了所有的收费方式，商场是可能经常性地更改打折额度和返利额度，每次维护或扩展收费都要改动这个工厂，以致代码需要重新便已部署，这真是很糟糕的处理方式，所以用它不是最好的方法。面对算发的时常变动，应该有更好的办法。

　　策略模式（Strategy）：它定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。商场收银时如何促销，用打折还是返利，其实都是一些算法，用工厂来生成算法对象，这没有错，但算法本身只是一种策略，最重要的是这些算法是随时都可能相互替换的，这就是变化点，而封装变化点是我们面向对象的一种很重要的思维方式。

/*******Strategy类，定义所有支持的算法的公共接口*********/
//抽象算法类
class Strategy
{
public:
    //算法方法
    virtual void AlgorithmInterface()=0;
};
/******ConcreteStategy，封装了具体的算法或行为，继承与Strategy*********/
//具体算法A
class ConcreteStrategyA:public Strategy
{
public:
    void AlgorithmInterface()
    {
        cout << "算法A的实现" << endl;
    }
};
//具体算法B
class ConcreteStrategyB:public Strategy
{
public:
    void AlgorithmInterface()
    {
        cout << "算法B的实现" << endl;
    }
};
//具体算法C
class ConcreteStrategyC:public Strategy
{
public:
    void AlgorithmInterface()
    {
        cout << "算法C的实现" << endl;
    }
};
/*******Context，用一个ConcreteStrategy来配置，维护一个对Stategy对象的引用************/
//上下文
class Context
{
private:
    Strategy *strategy;
public:
    //初始化时，传入具体的策略对象
    Context(Strategy *pstrategy):strategy(pstrategy){};
    //上下文接口
    //根据具体的策略对象，调用其算法的方法
    void ContestInterface()
    {
        strategy->AlgorithmInterface();
    }
};

CashSuper是抽象策略，正常收费CashNormal、打折收费CashRebate和返利CashReturn就是三个具体策略，也就是策略模式中的具体算法。

#include <iostream>
using namespace std;
//现金收费抽象类
class CashSuper
{
public:
    virtual double acceptCash(double money)=0;
};
//正常收费子类
class CashNormal:public CashSuper
{
public:
    double acceptCash(double money)
    {
        return money;
    }
};
//打折收费子类
class CashRebate:public CashSuper
{
private:
    double moneyRebate;
public:
    CashRebate(double moneyRebate)
    {
        this->moneyRebate=moneyRebate;
    }
    double acceptCash(double money)
    {
        return money*moneyRebate;
    }
};
//返利收费子类
class CashReturn:public CashSuper
{
private:
    double moneyCondition;
    double moneyReturn;
public:
    CashReturn(double moneyCondition,double moneyReturn)
    {
        this->moneyCondition=moneyCondition;
        this->moneyReturn=moneyReturn;
    }
    double acceptCash(double money)
    {
        double result=money;
        if(money>=moneyCondition)
            result=money-(money/moneyCondition)*moneyReturn;
        return result;
    }
};
class CashContext
{
private:
    CashSuper *cs;
public:
    CashContext(CashSuper *csuper)
    {
        this->cs=csuper;
    }
    CashContext(int type)
    {
        switch(type)
        {
        case 1://正常模式
            cs=new CashNormal();
            break;
        case 2://打八折
            cs=new CashRebate(0.8);
            break;
        case 3:
            cs=new CashReturn(300,100);
            break;
        default:
            break;
        }
    }
    double GetResult(double money)
    {
        return cs->acceptCash(money);
    }
    ~CashContext()
    {
        delete cs;
    }
};
int main()
{
    double total=0;
    CashContext *csuper = new CashContext(2);
    double totalPrices = 0;
    totalPrices = csuper->GetResult(300.0);
    total = total+totalPrices;

    cout << " total = "<<total<<endl;
    return 0;
}

总结：

　　策略模式是一种定义一系列算法的方法，从概念上看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有算法，减少了各种算法类与使用算法类之间的耦合。策略模式的Strategy类层次为Context定义了一系列的可供重用的算法或行为。继承有助于析取出这些算法中的公共功能。另外策略模式还简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试。

　　总之，策略模式就是用来封装算法的，但在实践中，我们发现可以用它来封装几乎任何类型的规则，只要在分析过程中听到在不同时间不同应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性。但在基本的策略模式中，选择所用具体实现的职责有客户端对象承担，并转给策略模式的Context对象。这本身没有解除客户端选择判断的压力，而策略模式和简单工厂模式结合后，选择具体实现的职责也可以由Context来承担，这就最大化减轻了客户端的职责。