一、UML图
二、包含的角色
策略模式包含三个角色:
(1)策略类Strategy: 策略类定义所有支持的算法的公共接口
(2)具体策略类ConcreteStrategy:具体策略类,封装了具体算法或行为,继承自Strategy。
(3)上下文Context: 上下文类,用一个ConcreteStrategy来配置,维护一个对Strategy对象的引用。
三、特点
(1)策略模式是一种定义一系列算法的方法,所有这些算法完成的都是相同的工作,只是实现不同。策略模式,可以以相同的方式调用所有的算法,减少了各种算法类与使用算法类之间的耦合。
(2)策略模式的strategy类层次为Context定义了一系列的可供重用的算法或行为,继承有助于析取这些算法中的公共功能。
(3)策略模式简化了单元测试,因为每个算法都有自己的类,可以通过自己的接口单独测试。
(4)策略模式就是用来封装算法的,实践中,我们发现其实可以用它来封装几乎任何类型的规则,只要在分析过程中听到需要在不同时间应用不同的业务规则,就可以考虑用策略模式处理这种变化的可能性。
(5)可以将简单工程模式和策略类相结合使用。从而减轻客户端的责任。
四、代码实现
这里主要实现c++的,策略模式与简单工厂模式相结合的版本。
class Strategy
{
public:
virtual void AlgoritlInterface();
};
#include "Strategy.h"
class ConcreteStrategyA : public Strategy
{
void AlgoritlInterface()
{
printf("ConcreteStrategy C 实现!");
}
};
这里ConcreteStrategyB和ConcreteStrategyC同ConcreteStrategyA,主要实现Context类。
Context.h
class Context
{
public:
Context(int type);
~Context();
private:
Strategy* strategy;
public:
void ContextInterface();
};
Context(int type);
~Context();
private:
Strategy* strategy;
public:
void ContextInterface();
};
Context.cpp
#include "Context.h"
#include "ConcreteStrategyA.h"
#include "ConcreteStrategyB.h"
#include "ConcreteStrategyC.h"
Context::Context(int type):strategy(NULL )
{
switch (type)
{
case 1:
strategy = new ConcreteStrategyA();
break;
case 2:
strategy = new ConcreteStrategyB();
break;
case 3:
strategy = new ConcreteStrategyC();
break;
default:
break;
}
}
Context::~Context()
{
if (strategy!=NULL)
{
delete strategy;
strategy = NULL;
}
}
void Context::ContextInterface()
{
return strategy->AlgoritlInterface();
}
调用方式如下: 很显然只暴露Context类给客户端
#include "Context.h"
int main()
{
//A
Context* cc1 = NULL;
cc1 = new Context(1);
cc1->ContextInterface(); //工作
//B
Context* cc2 = NULL;
cc2 = new Context(2);
cc2->ContextInterface();
//C
Context* cc3 = NULL;
cc3 = new Context(3);
cc3->ContextInterface();
if (cc1 != NULL)
{
delete cc1;
cc1 = NULL;
}
if (cc2 != NULL)
{
delete cc2;
cc2 = NULL;
}
if (cc3 != NULL)
{
delete cc3;
cc3 = NULL;
}
system("pause");
return 0;
}