（二）策略模式_策略模式怎么跟抽象方法结合

简单工厂模式只是解决对象的创建问题，而且由于工厂本身包括了所有的收费方式，商场可能经常性的更改打折额度和返利额度，每次维护或者扩展收费方式都要改动这个工厂，以致代码需要重新编译部署，这不是一种好方法。而且为了创建不同的对象产品使用了switch case（或if else）的形式实现代码，这样违背了开闭原则，即对扩展开放、对修改封闭，维护的成本会随着cese（或else）的增加而增加，而本文的策略模式能较好地解决这个问题。

 策略模式是处理算法不同变体的一种行为型模式。策略模式通过接口或抽象类提供公共的函数接口，即在抽象类中定义一个抽象方法，实现该接口的派生类将实现该抽象类中的抽象方法。策略模式把针对不同派生类一系列的具体算法分别封装在不同的派生类中，使得各个派生类给出的具体算法可以相互替换。

在策略模式中，抽象类提供公共的函数接口称作策略，实现该接口的派生类称作具体策略。

• Strategy （抽象算法接口）: 定义所有算法的公共函数接口(AlgorithmInterface)。Context 使用这个接口去调用 其派生类定义的具体算法。
• 具体策略（ConcreteStrategy）：具体策略是实现策略接口的类。具体策略实现策略接口所定义的抽象方法，即给出算法标识的具体算法。
• Context : 用来维护 Strategy  的派生类不同对象的不同算法实现。

Strategy是使用接口还是抽象类，这个取决于一系列的策略中是否有共同属性或方法；如果没有，使用接口更加灵活方便，反之使用抽象类，抽象类中便可存放公共的属性以及方法。
 

它定义了算法家族,分别封装起来,让他们之间可以互相转换,此模式让算法的变化,不会影响到使用算法的客户

场景:

商场售卖商品的时候针对不同场景指定不同的折扣策略(原价消费/折扣消费/返利消费),通过构建不同的对象来实现不同策略切换.

实现策略模式

#include<iostream>
#include<string>
#include<vector>
#include<stack>
#include<cmath>
using namespace std;
 
/**
 * 现金收费抽象类
 */
class CashSuper {
    /**
     * 现金收取超类的抽象方法,收取现金
     * @param money 原价
     * @return 当前价
     */
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;
    /**
     * 打折收费,初始化时,必须输入折扣率,如八折,就是0.8
     *
     * @param moneyRebate
     */
public:
    CashRebate(double moneyRebate) {
        this->moneyRebate = moneyRebate;
    }
 
    double acceptCash(double money) {
        return money * moneyRebate;
    }
};
 
/**
 * 返利收费子类
 */
class CashReturn: public CashSuper {
private:
    double moneyCondition;
    /**
     * 返利金额,即满足条件以后返还X元
     */
    double moneyReturn;
 
    /**
     * 返利收费,初始化时必须输入返利条件和返利金额,比如满300元减100元,则moneyCondition=300,moneyReturn=100
     *
     * @param moneyCondition 返利条件
     * @param moneyReturn    返利金额
     */
public:
    CashReturn(double moneyCondition, double moneyReturn) {
        this->moneyCondition = moneyCondition;
        this->moneyReturn = moneyReturn;
    }
 
    double acceptCash(double money) {
        double result = money;
        //若消费金额大于返利条件就进行返利计算
        if (money > moneyCondition) {
            //结果=总消费金额-(总金额整除返利条件)*返还金额,例如消费910元,610=910-(910/300)*100
            result = money - (int) floor(money/moneyCondition) * moneyReturn;
        }
        return result;
    }
};
 
/**
 * 策略上下文类
 */
class CashContext {
 
    /**
     * 策略
     */
private:
    CashSuper *cs;
 
    /**
     * 初始化要使用的策略
     *
     * @param cSuper
     */
public:
    CashContext(CashSuper *cSuper) {
        this->cs = cSuper;
    }
 
    /**
     * 获得计算结果
     *
     * @param money
     */
    double GetResult(double money) {
        return cs->acceptCash(money);
    }
};
 
 
 
int main(int argc, char * args[]){
        //返回结果
        double total;
        //采用正常收费策略
        CashSuper *cs;
        CashContext *cc;
 
        cs = new CashNormal();
        cc = new CashContext(cs);
        total = cc->GetResult(910);
        cout<<"采用正常收费策略:"<<total<<endl;
        //采用打折收费策略
        cs = new CashRebate(0.8);
        cc = new CashContext(cs);
        total = cc->GetResult(910);
        cout<<"采用打折收费策略:"<<total<<endl;
        //采用返利收费策略
        cs = new CashReturn(300, 100);
        cc = new CashContext(cs);
        total = cc->GetResult(910);
        cout<<"采用返利收费策略:"<<total<<endl;
 
        return 0;
}

策略模式与工厂模式结合

/**
 * 策略上下文类
 */
class CashContext {
 
    /**
     * 策略
     */
private:
    CashSuper *cs;
 
    /**
     * 初始化要使用的策略
     *
     * @param cSuper
     */
public:
    CashContext(int i) {
        switch(i)
        {
            case 1:
                cs = new CashNormal();
                break;
            case 2:
                cs = new CashRebate(0.8);
                break;
            case 3:
                cs = new CashReturn(300, 100);
                break;
        }
    }
 
    /**
     * 获得计算结果
     *
     * @param money
     */
    double GetResult(double money) {
        return cs->acceptCash(money);
    }
};
 
 
 
int main(int argc, char * args[]){
        //返回结果
        double total;
        //采用正常收费策略
        CashContext *cc;
 
        cc = new CashContext(1);
        total = cc->GetResult(910);
        cout<<"采用正常收费策略:"<<total<<endl;
        //采用打折收费策略
 
        cc = new CashContext(2);
        total = cc->GetResult(910);
        cout<<"采用打折收费策略:"<<total<<endl;
        //采用返利收费策略
 
        cc = new CashContext(3);
        total = cc->GetResult(910);
        cout<<"采用返利收费策略:"<<total<<endl;
 
        return 0;
}

优点：

• 策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，他可以以相同的方式调用所有的算法，如打折和返利都是为了完成计算价格的工作。它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。
• 策略模式的Strategy类曾是为Context定义了一些列的可供重用的算法或行为。集成有助于析取出这些算法中的公共功能。策略模式简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试。
• 策略模式就是用来封装算法的，但在实践中，我们可以用它来封装几乎任何类型的规则，只要在分析过程中听到需要在不同时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性。
• 简单工厂模式需要让客户端认识两个类，而策略模式和简单工厂模式结合的用法，客户端只需要认识一个类Context即可。
• 策略模式是为了适应不同的需求，只把变化点封装了，这个变化点就是实现不同需求的算法，但是，用户需要知道各种算法的具体情况。 就像上面的打折返利等活动，不同的打折返利情况，有不同的算法。我们不能在程序中将计算打折返利的算法进行硬编码，而是能自由的变化的。这就是策略模式。