设计模式学习_策略模式

Posted Leslie X徐

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了设计模式学习_策略模式相关的知识,希望对你有一定的参考价值。

第一章 策略模式

课题项目:模拟鸭子游戏

开始项目

思路第1版
1.设计一个超类Duck,成员为"呱呱叫"、“游泳”、“飞行”、“外观”
2.根据超类设计了几个子类比如鸳鸯、绿头鸭,修改了"外观"的表现

然而新的需求来了,需要加入“小黄鸭”玩具和“诱饵鸭”
小黄鸭不能飞行,叫声为“吱吱”。诱饵鸭不会飞也不会叫。
对于小黄鸭和诱饵鸭都需要覆写 飞行 和 呱呱叫 方法。
这种利用继承来提供Duck的行为,会导致以下缺点:
- 代码在多个子类中重复
- 运行时的行为不容易改变
- 很难知道所有鸭子的全部行为
- 改变会牵一发而动全身,造成其他鸭子不想要的改变

分离行为

设计原则1:找出应用中可能需要变化之处,把它们独立出来,不要和那些不需要变化的代码混在一起。
- 实现:把会变化的部分取出来并“封装”起来,让其他部分不受到影响。
- 结果:代码变化引起的不经意后果变少,系统变得更有弹性。

设计原则2:针对接口编程,而不是针对实现编程。
- 实现:将行为放在分开的类中,此类专门提供某行为接口的实现
- 结果:这样鸭子类就不再需要知道行为的实现细节,系统变得更有弹性。

思路第2版:
1.将飞行行为和呱呱叫行为从鸭类超类中取出分离
2.在鸭类中包含设定行为的方法,这样就可以在“运行时”动态地改变绿头鸭的飞行行为等。
3.鸭子现在会将飞行和呱呱叫的动作“委托”别人处理,而不是使用定义在Duck类内的呱呱叫和飞行方法。

整合行为后的代码:

/*
 * Duck.cxx
 * 
 * 
 */


#include <iostream>
using namespace std;

/****** 飞行动作接口 ******/
class FlyBehavior
{
	public:
	virtual void fly()=0;
};

class Fly_WithWings: public FlyBehavior
{
	void fly() {cout<<"I'm flying!\\n";}
};

class Fly_NoFly: public FlyBehavior
{
	void fly() {cout<<"I can't fly...\\n";}
};

/****** 叫声动作接口 ******/
class QuackBehavior
{
	public:
	virtual void quack()=0;
};

class Quack_quack: public QuackBehavior
{
	void quack() {cout<<"quack!quack!\\n";}
};

class Quack_mute: public QuackBehavior
{
	void quack() {cout<<"<< silence >>\\n";}
};

class Quack_zhizhi: public QuackBehavior
{
	void quack() {cout<<"Zhi! zhi!\\n";}
};

/** 鸭类 **/
class Duck
{
	protected:
		FlyBehavior *flybehavior;
		QuackBehavior *quackbehavior;
		
	public:
		Duck(){}
	
		void performQuack() 		{quackbehavior->quack();}
		void performFly() 			{flybehavior->fly();}
		
		void swim() {cout<<"all duck float,even decoys!\\n";}
		virtual void display()=0;
};

class MallardDuck : public Duck
{
	public:
		MallardDuck() {
			quackbehavior 	= new Quack_quack(); //叫声是呱呱叫
			flybehavior 			= new Fly_WithWings(); //能够用翅膀飞行
		}
		void display(){cout<<"I'm a Mallard duck\\n";}
};

class YellowDuck : public Duck
{
	public:
		YellowDuck() {
			quackbehavior 	= new Quack_zhizhi(); //叫声是吱吱叫
			flybehavior 			= new Fly_NoFly(); //不能飞行
		}
		void display(){cout<<"I'm a yellow duck\\n";}
};

class DecoyDuck : public Duck
{
	public:
		DecoyDuck() {
			quackbehavior 	= new Quack_mute(); //叫声是吱吱叫
			flybehavior 			= new Fly_NoFly(); //不能飞行
		}
		void display(){cout<<"I'm a Decoy Duck\\n";}
};

int main(int argc, char **argv)
{
	Duck *mallard = new MallardDuck();
	cout<<"mallard duck\\n";
	mallard->performFly();
	mallard->performQuack();
	cout<<"\\n";
	
	 mallard = new YellowDuck();
	cout<<"YellowDuck\\n";
	mallard->performFly();
	mallard->performQuack();
	cout<<"\\n";
	
	 mallard = new DecoyDuck();
	cout<<"DecoyDuck\\n";
	mallard->performFly();
	mallard->performQuack();
	cout<<"\\n";
	
	return 0;
}



输出:

mallard duck
I'm flying!
quack!quack!

YellowDuck
I can't fly...
Zhi! zhi!

DecoyDuck
I can't fly...
<< silence >>


动态设定行为

在抽象鸭类中加入两个新方法,实现在运行时动态切换鸭子的行为

void setFlyBehavior(FlyBehavior* fb) {flybehavior = fb;}
void setQuackBehavior(QuackBehavior* qb) {quackbehavior = qb;}
/** 鸭类 **/
class Duck
{
	protected:
		FlyBehavior *flybehavior;
		QuackBehavior *quackbehavior;
		
	public:
		Duck(){}
		
		void setFlyBehavior(FlyBehavior* fb) {flybehavior = fb;}
		void setQuackBehavior(QuackBehavior* qb) {quackbehavior = qb;}
	
		void performQuack() 		{quackbehavior->quack();}
		void performFly() 			{flybehavior->fly();}
		
		void swim() {cout<<"all duck float,even decoys!\\n";}
		virtual void display()=0;
};

/** 加入一个飞行动作 **/
class Fly_Rocket: public FlyBehavior
{
	void fly() {cout<<"I'm flying like rocket!\\n";}
};

/** 实现动态切换 **/
int main(int argc, char **argv)
{
	Duck *duck = new DecoyDuck();
	cout<<"DecoyDuck\\n";
	
	duck->performFly();
	duck->performQuack();
	cout<<"\\n";
	
	duck->setFlyBehavior((new Fly_Rocket()));
	duck->performFly();
	
	return 0;
}

策略模式总结

定义算法族,分别封装起来,让他们之间可以相互替换,此模式让算法的变化独立于使用算法的用户。

例子:
在这里插入图片描述

以上是关于设计模式学习_策略模式的主要内容,如果未能解决你的问题,请参考以下文章

策略模式-设计模式

在策略模式中使用带有自定义属性的 bgl dijsktra 代码

设计模式_策略方法

Python设计模式-策略模式

JavaScript 设计模式之策略模式

python设计模式第九天策略模式