剛剛加班回來；哎，公司規定平時加班只有10塊錢的餐補；星期六和星期天加班，只給串休假；在國家規定的節假日按照3倍工資發放。那麼對於這麼多的計算加班費的方法，公司的OA系統是如何進行做的呢？這就要說到今天我這裡總結的策略設計模式了。
在GOF的《設計模式:可復用面向對象軟件的基礎》一書中對策略模式是這樣說的：定義一系列的算法，把它們一個個封裝起來，並且使它們可相互替換。該模式使得算法可獨立於使用它的客戶而變化。
策略模式為了適應不同的需求，只把變化點封裝了，這個變化點就是實現不同需求的算法，但是，用戶需要知道各種算法的具體情況。就像上面的加班工資，不同的加班情況，有不同的算法。我們不能在程序中將計算工資的算法進行硬編碼，而是能自由的變化的。這就是策略模式。
Strategy：定義所有支持的算法的公共接口。Context使用這個接口來調用某ConcreteStrategy定義的算法；
ConcreteStrategy：實現Strategy接口的具體算法；
Context：使用一個ConcreteStrategy對象來配置；維護一個對Stategy對象的引用，同時，可以定義一個接口來讓Stategy訪問它的數據。
當存在以下情況時使用Strategy模式：
首先實現最單純的策略模式，代碼如下：
#include <iostream>using namespace std;// The abstract strategyclass Strategy{public:
virtual void AlgorithmInterface() = 0;};class ConcreteStrategyA : public Strategy{public:
void AlgorithmInterface()
{
cout<<"I am from ConcreteStrategyA."<<endl;
}};class ConcreteStrategyB : public Strategy{public:
void AlgorithmInterface()
{
cout<<"I am from ConcreteStrategyB."<<endl;
}};class ConcreteStrategyC : public Strategy{public:
void AlgorithmInterface()
{
cout<<"I am from ConcreteStrategyC."<<endl;
}};class Context{public:
Context(Strategy *pStrategyArg) : pStrategy(pStrategyArg)
{
}
void ContextInterface()
{
pStrategy->AlgorithmInterface();
}private:
Strategy *pStrategy;};int main(){
// Create the Strategy
Strategy *pStrategyA = new ConcreteStrategyA;
Strategy *pStrategyB = new ConcreteStrategyB;
Strategy *pStrategyC = new ConcreteStrategyC;
Context *pContextA = new Context(pStrategyA);
Context *pContextB = new Context(pStrategyB);
Context *pContextC = new Context(pStrategyC);
pContextA->ContextInterface();
pContextB->ContextInterface();
pContextC->ContextInterface();
if (pStrategyA) delete pStrategyA;
if (pStrategyB) delete pStrategyB;
if (pStrategyC) delete pStrategyC;
if (pContextA) delete pContextA;
if (pContextB) delete pContextB;
if (pContextC) delete pContextC;}在實際操作的過程中，我們會發現，在main函數中，也就是在客戶端使用策略模式時，會創建非常多的Strategy，而這樣就莫名的增加了客戶端的壓力，讓客戶端的復雜度陡然增加了。那麼，我們就可以借鑒簡單工廠模式，使策略模式和簡單工廠模式相結合，從而減輕客戶端的壓力，代碼實現如下：
#include <iostream>using namespace std;// Define the strategy typetypedef enum StrategyType{
StrategyA,
StrategyB,
StrategyC}STRATEGYTYPE;// The abstract strategyclass Strategy{public:
virtual void AlgorithmInterface() = 0;
virtual ~Strategy() = 0; // 謝謝hellowei提出的bug，具體可以參見評論};Strategy::~Strategy(){}class ConcreteStrategyA : public Strategy{public:
void AlgorithmInterface()
{
cout << "I am from ConcreteStrategyA." << endl;
}
~ConcreteStrategyA(){}};class ConcreteStrategyB : public Strategy{public:
void AlgorithmInterface()
{
cout << "I am from ConcreteStrategyB." << endl;
}
~ConcreteStrategyB(){}};class ConcreteStrategyC : public Strategy{public:
void AlgorithmInterface()
{
cout << "I am from ConcreteStrategyC." << endl;
}
~ConcreteStrategyC(){}};class Context{public:
Context(STRATEGYTYPE strategyType)
{
switch (strategyType)
{
case StrategyA:
pStrategy = new ConcreteStrategyA;
break;
case StrategyB:
pStrategy = new ConcreteStrategyB;
break;
case StrategyC:
pStrategy = new ConcreteStrategyC;
break;
default:
break;
}
}
~Context()
{
if (pStrategy) delete pStrategy;
}
void ContextInterface()
{
if (pStrategy)
pStrategy->AlgorithmInterface();
}private:
Strategy *pStrategy;};int main(){
Context *pContext = new Context(StrategyA);
pContext->ContextInterface();
if (pContext) delete pContext;}在上面這個代碼中，其實，我們可能看到的更多的是簡單工廠模式的應用，我們將策略模式將簡單工廠模式結合在了一起，讓客戶端使用起來更輕松。
策略模式和狀態模式，是大同小異的；狀態模式講究的是狀態的變化，和不同狀態下，執行的不同行為；而策略模式側重於同一個動作，實現該行為的算法的不同，不同的策略封裝了不同的算法。策略模式適用於實現某一功能，而實現該功能的算法是經常改變的情況。在實際工作中，遇到了實際的場景，可能會有更深的體會。比如，我們做某一個系統，該系統可以適用於各種數據庫，我們都知道，連接某一種數據庫的方式是不一樣的，也可以說，連接數據庫的“算法”都是不一樣的。這樣，我們就可以使用策略模式來實現不同的連接數據庫的策略，從而實現數據庫的動態變換。
