设计模式学习22——策略模式

最新推荐文章于 2023-08-16 12:27:13 发布

demystify

最新推荐文章于 2023-08-16 12:27:13 发布

阅读量1.9k

点赞数 1

分类专栏：设计模式

本文链接：https://blog.csdn.net/xiaoxiaoyusheng2012/article/details/23092335

版权

设计模式专栏收录该内容

18 篇文章 1 订阅

订阅专栏

题外音：面向对象的编程，并不是类越多越好，类的划分是为了封装，但分类的基础是抽象，具有相同属性和功能的对象的抽象集合才是类。

参看：http://blog.csdn.net/lovelion/article/details/7819266

1、在软件开发过程中，经常会遇到这样的情况，实现某种功能有多种途径，每一条途径对应一种算法，此时我们可以使用一种设计模式来实现灵活地选择解决途径，也能够方便地增加新的途径，这就是为适应算法灵活性而产生的设计模式——策略模式。

2、每一种策略都是一种算法，将算法的定义与使用环境分离，正是策略模式所要解决的问题。

3、策略模式的主要目的是将算法的定义与使用分离，也就是将算法的行为与环境分开。将算法的定义放在专门的策略类中，每一个策略类封装了一种实现算法，使用算法的环境类针对抽象策略类进行编程，符合依赖倒转原则，在出现新的算法时，只需要增加一个新的实现了抽象策略类的具体策略类即可。

4、策略模式的定义：

策略模式（Strategy Pattern）：定义一系列算法类，将每一个算法封装起来，并让它们可以相互替换，策略模式让算法独立于使用它的客户而变化，也称为政策模式（Policy）。策略模式是一种对象行为型模式。

5、策略模式的结构图：

策略模式结构图中包含的几种角色：

1* Context(环境类)：环境类是使用算法的角色，它在解决某个问题（既实现某个方法）时可以采用多种策略。在环境类中维持一个抽象策略类的引用实例，用于定义所采用的策略。

2* AbstractStrategy(抽象策略类)：它为所支持的算法声明了抽象方法，是所有策略类的父类，它可以是抽象类或者具体类，也可以是接口。环境类通过抽象策略类中声明的方法在运行时调用具体策略类中实现的算法。

3* Strategy(策略类)：它实现了抽象策略类中声明的算法，在运行时具体策略类将覆盖在环境类中定义的抽象策略类对象，使用一种具体算法实现某个业务处理。

策略模式是一个比较容易理解和使用的设计模式，策略模式是对算法的封装，它把算法的责任和算法本身分割开，委派给不同的对象管理。策略模式通常把一个系列的算法封装到一系列具体策略类里面，作为抽象策略类的子类。在策略模式中，对环境类和抽象策略类的理解非常重要，环境类是需要使用算法的类。在一个系统中可以存在多个环境类，它们可能需要重用一些相同的算法。

6、策略模式使用总结

策略模式是一种定义一系列算法的方法，从概念上看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有算法，减少了各种算法类与使用算法类之间的耦合。

策略模式就是用来封装算法的，但在实践中，我们发现可以用它来封装几乎任何类型的规则，只要在分析过程中听到需要在不同的时间应用不同的规则时，就可以考虑使用策略模式处理这种变化的可能性。

<1>、策略模式的主要优点如下：

(1)策略模式提供了对“开闭原则”的完美支持，用户可以在不修改原有系统的基础上选择算法或行为，也可以灵活地增加新的算法或行为。

(2)策略模式提供了管理相关的算法族的办法。策略类的等级结构定义了一个算法或行为族，恰当使用继承可以把公共的代码移到抽象策略类中，从而避免重复的代码。

(3)策略模式提供了一种可以替换继承关系的办法。如果不使用策略模式，那么使用算法的环境类就可能会有一些子类，每一个子类提供一种不同的算法。但是，这样一来算法的使用就和算法本身混在一起，不符合“单一职责原则”，决定使用哪一种算法的逻辑和该算法本身混合在一起，从而不可能再独立演化；而且使用继承无法实现算法或行为在程序运行时的动态切换。

(4)使用策略模式可以避免多重条件选择语句。多重条件选择语句不易维护，它把采取哪一种算法或行为的逻辑与算法或行为本身的实现逻辑混合在一起，将它们全部硬编码(Hard Coding)在一个庞大的多重条件选择语句中，比直接继承环境类的办法还要原始和落后。

(5)策略模式提供了一种算法的复用机制，由于将算法单独提取出来封装在策略类中，因此不同的环境类可以方便地复用这些策略类。

<2>、策略模式的主要缺点如下：

(1) 客户端必须知道所有的策略类，并自行决定使用哪一个策略类。这就意味着客户端必须理解这些算法的区别，以便适时选择恰当的算法。换言之，策略模式只适用于客户端知道所有的算法或行为的情况。

(2) 策略模式将造成系统产生很多具体策略类，任何细小的变化都将导致系统要增加一个新的具体策略类。

(3) 无法同时在客户端使用多个策略类，也就是说，在使用策略模式时，客户端每次只能使用一个策略类，不支持使用一个策略类完成部分功能后再使用另一个策略类来完成剩余功能的情况。

<3>、在以下情况下可以考虑使用策略模式：

(1) 一个系统需要动态地在几种算法中选择一种，那么可以将这些算法封装到一个个的具体算法类中，而这些具体算法类都是一个抽象算法类的子类。换言之，这些具体算法类均有统一的接口，根据“里氏代换原则”和面向对象的多态性，客户端可以选择使用任何一个具体算法类，并只需要维持一个数据类型是抽象算法类的对象。

(2) 一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重条件选择语句来实现。此时，使用策略模式，把这些行为转移到相应的具体策略类里面，就可以避免使用难以维护的多重条件选择语句。

(3) 不希望客户端知道复杂的、与算法相关的数据结构，在具体策略类中封装算法与相关的数据结构，可以提高算法的保密性与安全性。

7、简单工厂模式与策略模式的比较

<1>、简单工厂模式的目的是：将对象的创建与对象的使用分离。只需要向工厂方法中传入正确的参数，就可以得到想要的对象。降低客户端的复杂性。

<2>、策略模式的目的是：表达对象行为的可变性，体现策略之间的可替换性，即完成某件事情时，多种可行方法之间的灵活切换。

8、附上练习题及代码

练习：Sunny软件公司欲开发一款飞机模拟系统，该系统主要模拟不同种类飞机的飞行特征与起飞特征，需要模拟的飞机种类及其特征如
飞机种类及特征一览表

飞机种类                        起飞特征                     飞行特征

直升机(Helicopter)       垂直起飞(VerticalTakeOff)       亚音速飞行(SubSonicFly)

客机(AirPlane)         长距离起飞(LongDistanceTakeOff)   亚音速飞行(SubSonicFly)

歼击机(Fighter)        长距离起飞(LongDistanceTakeOff)   超音速飞行(SuperSonicFly)

鹞式战斗机(Harrier)    垂直起飞(VerticalTakeOff)         超音速飞行(SuperSonicFly)

为将来能够模拟更多种类的飞机，试采用策略模式设计该飞机模拟系统。

结构图：

代码：

/* Strategy.h */
#ifndef STRATEGY_H
#define STRATEGY_H
#include <string>
#include <iostream>
using namespace std;

class AbstractFly;
class AbstractTakeOff;

//------------------------------------------------------------
//飞行方式
class AbstractFly
{
public:
	virtual void Fly(){};
};

class SubSonicFly : public AbstractFly
{
public:
	void Fly(){cout<<"亚音速飞行！"<<endl;};
};

class SuperSonicFly : public AbstractFly
{
public:
	void Fly(){cout<<"超音速飞行！"<<endl;};
};

//------------------------------------------------------------
//起飞方式
class AbstractTakeOff
{
public:
	virtual void TakeOff(){};
};

class VerticalTakeOff : public AbstractTakeOff
{
public:
	void TakeOff(){cout<<"垂直起飞！"<<endl;};
};

class LongDistanceTakeOff : public AbstractTakeOff
{
public:
	void TakeOff(){cout<<"长距离起飞！"<<endl;};
};

//------------------------------------------------------------
//飞机类型

enum FlyMode{subSonicFly=1, superSonicFly};
enum TakeOffMode{verticalTakeOff=1, longDistanceTakeOff};
class AbstractPlane
{
public:
	AbstractPlane()
	{
       m_pFlyMode = NULL;
	   m_pTakeOffMode =NULL;
	   Num++;
	   m_PlaneNo = Num;
	};
	~AbstractPlane()
	{
		if(m_pFlyMode != NULL)
			delete m_pFlyMode;
		if(m_pTakeOffMode != NULL)
			delete m_pTakeOffMode;
		Num--;
	};

	AbstractPlane(string Name, TakeOffMode takeoffmode, FlyMode flymode)
	{
		m_Name = Name;
        m_pFlyMode = SetFlyMode(subSonicFly);
		//ASSERT(m_pFlyMode != NULL);
		m_pTakeOffMode = SetTakeOffMode(verticalTakeOff);
		//ASSERT(m_pTakeOffMode != NULL);
		Num++;
		m_PlaneNo = Num;
	};
	static AbstractFly* SetFlyMode(FlyMode flaymode)
	{
		AbstractFly* pResult = NULL;
		switch(flaymode)
		{
		case subSonicFly:
			pResult = new SubSonicFly();
			break;
		case superSonicFly:
			pResult = new SuperSonicFly();
			break;
		default:
			break;
		}
		return pResult;
	};

	static AbstractTakeOff* SetTakeOffMode(TakeOffMode takeoffmode)
	{
		AbstractTakeOff* pResult = NULL;
		switch(takeoffmode)
		{
		case verticalTakeOff:
			pResult = new VerticalTakeOff();
			break;
		case longDistanceTakeOff:
			pResult = new LongDistanceTakeOff();
			break;
		default:
			break;
		}
		return pResult;
	};
	
	virtual void MoniRun()
	{
		cout<<"----------------------------------"<<endl;
	   	cout<<"我是：飞机"<<m_PlaneNo<<"号"<<endl;
		cout<<"飞机类型："<<m_PlaneType<<endl;
		cout<<"我开始起飞！"<<endl;
		m_pTakeOffMode->TakeOff();
		cout<<"起飞完成！，开始巡航"<<endl;
		m_pFlyMode->Fly();
		cout<<"模拟表演结束，谢谢！"<<endl;
	};
protected:
   string m_Name;
   string m_PlaneType;
   AbstractFly* m_pFlyMode;
   AbstractTakeOff* m_pTakeOffMode;
   int m_PlaneNo;
   static int Num;
};

int AbstractPlane::Num = 0;


class Helicopter : public AbstractPlane
{
public:
	Helicopter()
	{
		m_PlaneType = "Helicopter";
		m_pFlyMode = SetFlyMode(subSonicFly);
		m_pTakeOffMode = SetTakeOffMode(verticalTakeOff);
	};

	Helicopter(string Name, TakeOffMode takeoffmode, FlyMode flymode):AbstractPlane(Name, takeoffmode, flymode){};
};

class AirPlane : public AbstractPlane
{
public:
	AirPlane()
	{
		m_PlaneType = "AirPlane";
		m_pFlyMode = SetFlyMode(subSonicFly);
		m_pTakeOffMode = SetTakeOffMode(longDistanceTakeOff);
	};
	AirPlane(string Name, TakeOffMode takeoffmode, FlyMode flymode):AbstractPlane(Name, takeoffmode, flymode){};
};

class Fighter : public AbstractPlane
{
public:
	Fighter()
	{
		m_PlaneType = "Fighter";
		m_pFlyMode = SetFlyMode(superSonicFly);
		m_pTakeOffMode = SetTakeOffMode(longDistanceTakeOff);
	};
	Fighter(string Name, TakeOffMode takeoffmode, FlyMode flymode):AbstractPlane(Name, takeoffmode, flymode){};
};

class Harrier : public AbstractPlane
{
public:
	Harrier()
	{
		m_PlaneType = "Harrier";
		m_pFlyMode = SetFlyMode(superSonicFly);
		m_pTakeOffMode = SetTakeOffMode(verticalTakeOff);
	};
	Harrier(string Name, TakeOffMode takeoffmode, FlyMode flymode):AbstractPlane(Name, takeoffmode, flymode){};
};
#endif

/* Strategy.cpp*/
#include "Strategy.h"
#include <vector>


int main(int argc , char** argv)
{
	vector<AbstractPlane*> m_AllPlaneVector;
	
	AbstractPlane* pTempPlane = NULL;
	
	pTempPlane = new Helicopter();
	m_AllPlaneVector.push_back(pTempPlane);

	pTempPlane = new AirPlane();
	m_AllPlaneVector.push_back(pTempPlane);

    pTempPlane = new Fighter();
	m_AllPlaneVector.push_back(pTempPlane);

	pTempPlane = new Harrier();
	m_AllPlaneVector.push_back(pTempPlane);

	for(int i=0; i<m_AllPlaneVector.size(); i++)
	{
		m_AllPlaneVector[i]->MoniRun();
	}

	for(int j=0; j<m_AllPlaneVector.size(); j++)
	{
		if(m_AllPlaneVector[j] != NULL)
		{
			delete m_AllPlaneVector[j];
			m_AllPlaneVector[j] = NULL;
		}
	}
	return 0;
}

补充：

1、策略模式就是用来封装算法的，但在实践中，我们发现可以用它来封装几乎所有类型的规则，只要在分析过程中听到需要在不同时间应用不同的业务规则时，就可以考虑使用策略模式来处理这种变化的可能性。