设计模式---策略模式（strategy）

 策略模式（strategy）

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

不废话，看UML图和对应C++代码：

对应C++代码：

/**
* date:2012/02/27
* Item:Learn strategy pattern
* name:smile
**/
#include <iostream>
using namespace std;
#define NORMAL 1
#define REBATE 2
#define RETURN 3
class Abs_Arithmetic
{
public:
virtual double GetTotalPrice(int num,double price) = 0;
virtual void InitValue(double rebate = 0.0,
double conditionmoney = 0.0,double Returnmoney = 0.0) = 0;
};
class NormalArithmetic:public Abs_Arithmetic
{
public:
void InitValue(double rebate = 0.0,
double conditionmoney = 0.0,double Returnmoney = 0.0){}
double GetTotalPrice(int num,double price)
{
return double(num)*price;
}
};
class RebateArithmetic:public Abs_Arithmetic
{
public:
void InitValue(double rebate = 0.0,
double conditionmoney = 0.0,double Returnmoney = 0.0)
{
Rebate = rebate;
}
double GetTotalPrice(int num,double price)
{
return double(num)*price*Rebate;
}
private:
double Rebate;
};
class ReturnArithmetic:public Abs_Arithmetic
{
public:
void InitValue(double rebate = 0.0,
double conditionmoney = 0.0,double Returnmoney = 0.0)
{
ConditionMoney = conditionmoney;
ReturnMoney = Returnmoney;
}
double GetTotalPrice(int num,double price)
{
double totalMoney = double(num)*price;
if(totalMoney >= ConditionMoney)
totalMoney -= totalMoney/ConditionMoney*ReturnMoney;
return totalMoney;
}
private:
double ConditionMoney;
double ReturnMoney;
};
class Context
{
public:
Context():pAbs(NULL){}
double GetReturnMoney(int num,double price)
{
return pAbs->GetTotalPrice(num,price);
}
Abs_Arithmetic* CreateConcreteArithmetic(int salemode)
{
switch(salemode)
{
case NORMAL:
pAbs = new NormalArithmetic;
break;
case REBATE:
pAbs = new RebateArithmetic;
break;
case RETURN:
pAbs = new ReturnArithmetic;
break;
default:
break;
}
return pAbs;
}
~Context()
{
cout << "called destructor!" << endl;
if(NULL != pAbs)
delete pAbs;
}
private:
Abs_Arithmetic *pAbs;
};
int main()
{
int Sale_Mode(RETURN);
int TotalNum(200);
double Price(30);
double Rebate(0.75);
double ConditionMoney(100.00);
double ReturnMoney(30.00);
Context mct;
Abs_Arithmetic *p = mct.CreateConcreteArithmetic(Sale_Mode);
p->InitValue(0.0,ConditionMoney,ReturnMoney);
double AcceptMoney = mct.GetReturnMoney(TotalNum,Price);
cout << "Shoule accept: " << AcceptMoney << " $!" << endl;
return 0;
}

从抽象的算法类Abs_Arithmetic分别派生了具体类NormalArithmetic，RebateArithmetic和类ReturnArithmetic分别代表一种具体的算法

然后类Context保存来一个抽象类的指针（看，又是多态的灵活运用），另外Context类提供了一个接口来创建具体的算法对象，然后提供一个接口给客户端

这样有什么好处？这样就让算法对象的创建和用户彻底隔离了，隐藏了更多信息更容易维护。这样也容易扩展，要新算法直接派生个出来就行了，然后就可以替代原来的算法。

这些算法就是变化点，是可以替代的，封装变化点是面向对象中很很重要的思维方式。