设计模式学习_策略模式

第一章 策略模式

课题项目：模拟鸭子游戏

开始项目

思路第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;
}

策略模式总结

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

例子：