【设计模式】——策略模式
面向对象的编程，并不是类越多越好，类的划分是为了封装，但分类的基础是抽象，具有相同属性和功能的对象的抽象集合才是类。
在说策略模式之前，我们想用简单工厂模式来实现商场收银程序
#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来承担，这就最大化减轻了客户端的职责。
