设计模式解析（五）——几种设计模式之Strategy

《设计模式》一书中对Strategy模式的意图叙述如下：

定义一系列的算法，把它们一个个封装起来，并且使它们可以相互替换，Strategy模式使算法可独立于使用它的客户而变化。

strategy模式以下列原则为基础：

1.对象都具有职责

2.这些职责不同的具体实现是通过多态的使用完成的

3.概念上相同的算法具有多个不同的实现，需要进行管理

 

	Strategy模式：关键特征
意图	可以根据所处的上下文，使用不同的业务规划或算法
问题	对所需算的选择取决于发出请求的客户或者要处理的数据。如果只有一些不会变化的算法，就不需要Strategy模式。
解决方案	将对算法的选择和算法的实现相分离。允许根据上下文进行选择。
参与者与协作者	strategy指定了如何使用不同的算法。 各ConcreteStrategy实现了这些不同的算法。 Context通过类型为Strategy的引用使用具体的ConcreteStrategy。Strategy与Context相互作用以实现所选的算（有时候Strategy必须查询Context）。Context将来自Client的请求转发给Strategy。
效果	Strategy模式定义了一系列的算法。 可以不适用switch语句或条件语句。 必须以相同的方式调用所有的算法（它们必须拥有相同的接口）。个ConcreteStrategy与Context之间的相互作用可能需要在Context中加入获取状态的方法。
实现	让使用算法的类（Context）包含一个抽象类（Strategy），该抽象类有一个抽象方法指定如何调用算法。每个派生类按照需要实现算法。注意：在原型Strategy模式中，选择所用具有实现的职责由Client对象承担，并转给Strategy模式的Context对象。

Stategy模式的通用结构图

Strategy模式会带来爆炸性增长问题的解决方法

C++

可以用Strategy抽象类头文件包含所有ConcreteStrategy类的头文件。同时用|Strategy抽象类的cpp文件包含各ConcreteStrategy的代码。

Java

可以在Strategy抽象类内使用内部类包含所有的ConcreteStrategy。

但是如果无法控制所有的Strategy对象，也就是说如果有其它程序员需要实现自己的算法，就不要这么做。

代码示例：

//TaxController.h
#pragma once
#include "CalcTax.h"

class TaskController
{
public:
    TaskController(void);
    void process();
    CalcTax *getTaxRulesForCountry();
public:
    ~TaskController(void);
};
TaxController.cpp
#include "TaskController.h"
#include "SalesOrder.h"
#include "CalcTax.h"
#include "USTax.h"

TaskController::TaskController(void)
{
}

TaskController::~TaskController(void)
{
}

void TaskController::process ()
{
    // this code is an emulation of a 
    // processing task controller
    // . . .
    // figure out which country you are in
    CalcTax *myTax;
    myTax= getTaxRulesForCountry();
    SalesOrder *mySO= new SalesOrder();
    mySO->process( myTax);
}

CalcTax *TaskController::getTaxRulesForCountry() 
{
    // In real life, get the tax rules based on
    // country you are in.  You may have the
    // logic here or you may have it in a
    // configuration file
    // Here, just return a USTax so this 
    // will compile.
    return new USTax;
}

//SalesOrder.h
#pragma once
#include "CalcTax.h"

class SalesOrder
{
public:
    SalesOrder(void);
    void process (CalcTax *TaxToUse);
public:
    ~SalesOrder(void);
};
SalesOrder.cpp
#include "SalesOrder.h"

SalesOrder::SalesOrder(void)
{
}

SalesOrder::~SalesOrder(void)
{
}

void SalesOrder::process (CalcTax *taxToUse)
{
    long itemNumber= 0;
    double price= 0;

    // given the tax object to use

    // . . .

    // calculate tax
    double tax= taxToUse->taxAmount( itemNumber, price);
}

//CalcTax.h
#pragma once

class CalcTax
{
public:
    CalcTax(void);
    double virtual taxAmount( long, double)= 0;
public:
    ~CalcTax(void);
};
CalcTax.cpp
#include "CalcTax.h"

CalcTax::CalcTax(void)
{
}

CalcTax::~CalcTax(void)
{
}

//CanTax.h
#pragma once
#include "calctax.h"

class CanTax :
    public CalcTax
{
public:
    CanTax(void);
    double taxAmount( long, double);
public:
    ~CanTax(void);
};
CanTax.cpp
#include "CanTax.h"

CanTax::CanTax(void)
{
}

CanTax::~CanTax(void)
{
}

double CanTax::taxAmount (long itemSold, double price) 
{
    // in real life, figure out tax according to
    // the rules in Canada and return it
    // here, return 0 so this will compile
    return 0.0;
}

//USTax.h
#pragma once
#include "calctax.h"

class USTax :
    public CalcTax
{
public:
    USTax(void);
    double taxAmount( long, double);

public:
    ~USTax(void);
};
USTax.cpp
#include "USTax.h"

USTax::USTax(void)
{
}

USTax::~USTax(void)
{
}

double USTax::taxAmount (long itemSold, double price) 
{
    // in real life, figure out tax according to
    // the rules in the US and return it
    // here, return 0 so this will compile
    return 0.0;
}