【设计模式】策略模式与简单工厂结合

策略模式

大话设计模式

什么是策略模式（Strategy）？

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

策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。

在AbstractStrategy中定义所有支持算法的公共接口。
在Context上下文类中，用一个Strategy成员引用一个ConcreteStrategy，定义一个方法来调用strategy里的一组方法。
ConcreteStrategy类中，继承了AbstractStrategy，实现了具体的算法或行为。

策略模式与简单工厂结合

将工厂实现在context类中。代码实例：

#include <iostream>
using namespace std;
class AbstractStrategy{
public:
    virtual void algo1() = 0;
    virtual void algo2() = 0;
    virtual void algo3() = 0;
};

class StrategyA: public AbstractStrategy{
public:
    void algo1(){
        cout<<"A algo1"<<endl;
    }

    void algo2(){
        cout<<"A algo2"<<endl;
    }
    void algo3(){
        cout<<"A algo3"<<endl;
    }
};

class StrategyB: public AbstractStrategy{
public:
    void algo1(){
        cout<<"B algo1"<<endl;
    }

    void algo2(){
        cout<<"B alog2"<<endl;
    }

    void algo3(){
        cout<<"B algo3"<<endl;
    }
};

class StrategyC: public AbstractStrategy{
public:
    void algo1(){
        cout<<"C algo1"<<endl;
    }

    void algo2(){
        cout<<"C alog2"<<endl;
    }

    void algo3(){
        cout<<"C algo3"<<endl;
    }
};


class Context{
private:
    AbstractStrategy* strategy_;
public:
    Context() = default;
    Context(const int& type){
        switch(type){
            case 1:
                strategy_ = new StrategyA();
                break;
            case 2:
                strategy_ = new StrategyB();
                break;
            case 3:
                strategy_ = new StrategyC();
        }
    }
    void setStrategy(AbstractStrategy* strategy){
        strategy_ = strategy;
    }
    void runAlgorithms(){
        strategy_->algo3();
        strategy_->algo1();
        strategy_->algo2();
    }
};

int main(){
    Context context;
    AbstractStrategy* strategy = new StrategyA();
    context.setStrategy(strategy);
    context.runAlgorithms();
    Context context2(2);
    context2.runAlgorithms();
    return 0;
}

runAlgorithms()是对策略类中一系列算法的封装

策略模式的优点

策略模式的Strategy类层次为Context定义了一系列的可供重用的算法或行为。继承有助于析取出这些算法中的公共功能。
策略模式的优点是简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试[DPE]。
当不同的行为堆砌在一个类中时，就很难避免使用条件语句来选择合适的行为。将这些行为封装在一个个独立的Strategy类中，可以在使用这些行为的类中消除条件语句。
适用场景：策略模式就是用来封装算法的，但在实践中，我们发现可以用它来封装几乎任何类型的规则，只要在分析过程中听到需要在不同时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性。