第四课 策略模式（Strategy）

一. 动机

>> 在软件构建过程中，某些对象使用的算法可能多种多样，经常改变，如果将这些算法都编码到对象中，将会使对象变得异常复杂；而且有时候支持不适用的算法也是一个性能负担。

>> 如何在运行时根据需要透明地改变对象的算法啊？将算法与对象本身解耦，从而避免上述问题？

二. 样例

        假设有一个税种计算的需求，每个国家的税计算方式都是不一样的，目前有中国、美国及德国三个国家，第一种设计方式如下：

enum TaxBase{
    CN_Tax,
    US_Tax,
    DE_Tax
}

class SalesOrder{
    TaxBase tax;
public:
    double CalculateTax(){
        // ...

        if(tax == CN_Tax){ // ...}
        else if(tax == US_Tax){ // ...}
        else if(tax == DE_Tax){ // ...}
  
        // ...
};

        从动态的角度看，如果未来增加了日本或者法国的税计算，会是怎样的改动：

enum TaxBase{
    CN_Tax,
    US_Tax,
    DE_Tax,
    FR_Tax        // 更改 
}

class SalesOrder{
    TaxBase tax;
public:
    double CalculateTax(){
        // ...

        if(tax == CN_Tax){ // ...}
        else if(tax == US_Tax){ // ...}
        else if(tax == DE_Tax){ // ...}
        else if(tax == DE_Tax){ // ...}    // 更改
  
        // ...
};

        以上违背了开闭原则，不应该直接修改源代码来应对变化。以下是第二种方式：

class TaxStrategy{
public:
    virtual double Calculate(const Context& context) = 0;
    virtual ~TaxStrategy(){}
};

class CNTax : public TaxStrategy{
public:
    virtual double Calculate(const Context& context){ // ... }
};

class USTax: public TaxStrategy{
public:
    virtual double Calculate(const Context& context){ // ... }
};

class DETax: public TaxStrategy{
public:
    virtual double Calculate(const Context& context){ // ... }
};

class SalesOrder{
private:
    // 这里要放指针类型
    // 1. TaxStrategy含有纯虚函数，是个抽象类；
    // 2. 指针才具有多态性；
    // 3. 如果这里放的是引用，有可能会出现一些其他的问题，这里不做深入讨论 
    TaxStrategy* strategy;

public:
    SalesOrder(StrategyFactor* strategyFactory){
        // 这段使用工厂模式实现，暂不考虑，后续会有课程
        this->strategy = strategyFactory->NewStrategy();
    }

    ~SalesOrder(){ delete this->strategy; }

    public double CaculateTax(){
        // ...

        Context context();    

        // 多态调用，具体的返回类型，要看构造里返回的是什么
        double val = strategy->Calculate(context);

        // ...
    }
};

        直观上看，与第一种方式都能实现业务需求，而且第二种做法代码量明显增多，但考虑到业务变化时，代码改动如下：

class TaxStrategy{
public:
    virtual double Calculate(const Context& context) = 0;
    virtual ~TaxStrategy(){}
};

class CNTax : public TaxStrategy{ // 不变 };

class USTax: public TaxStrategy{ // 不变 };

class DETax: public TaxStrategy{ // 不变 };

// 扩展
class FRTax: public TaxStrategy{
public:
    virtual double Calculate(const Context& context){ // ... }
};

class SalesOrder{ // 不变 };

        第二种方式只需增加新的类，至于工厂模式里的变化，我们暂不做考虑。有人会说，第一种方式，只要增加一个else if即可，前面的几段条件也没有改动啊，但实际工程中，在原有代码里进行增加，往往会不小心就影响到原功能，导致以前好用的功能也变得不稳定。

三. 要点总结

>> Strategy及其子类为组件提供了一系列可重用的算法，从而使得类型在运行时方便地根据需要在各个算法之间进行切换；

>> Strategy模式提供了用条件判断语句以外的一种选择，消除条件判断语句，就是在解耦合。含有许多条件判断语句的代码，通常需要Strategy模式（有一些情况下的if else是不用策略模式的，比如if else是绝对稳定的情况，如一周有七天，这种情况可以使用七个if else来做相应的动作）；

>> 如果Strategy对象没有实例变量，那么各个上下文可以共享同一个Strategy对象，从而节省对象开销。