模式一：策略模式(Strategy Pattern)——實現可替換算法

• 策略模式

定義算法族，分別封裝起來，讓它們之間可以相互替換，此模式讓算法的變化獨立於使用算法的客戶。

• 應用分析——變化部分的實現

一種類型經常變化的部分，如果放在基類裏面，變化的子類需要重新實現，不利於代碼重用；

如果定義在抽象類裏面，通過繼承自不同的抽象類，可以獲得不同的行爲，這也可以實現，通常，繼承增加代碼之間的耦合度，用組合可以實現鬆耦合；

因此，我們定義行爲的算法族（抽象類），分別封裝實現（派生出不同的行爲對象），使它們之間可以相互替換，這樣，我們用相同的接口組合不同的行爲對象對象，就可以得到不同的行爲。

• 實例介紹——不同的鴨子：都會游泳；展示不同的外表；有的鴨子會飛，有的不會飛；有的呱呱叫，有的吱吱叫，有的不會叫。

• 代碼分析

<strong>//file:Behavior.h </strong>
#ifndef BEHAVIOR_H
#define BEHAVIOR_H

class FlyBehavior//飛行行爲抽象類 
{
	public:
		virtual void fly()=0;
};

class FlywithWings:public FlyBehavior//可以飛 
{
	public:
		virtual void fly();
};

class FlynoWay:public FlyBehavior//不能飛 
{
	public:
		virtual void fly();
};



class QuackBehavior//叫行爲抽象類 
{
	public:
		virtual void quack()=0;
};

class Quack:public QuackBehavior//呱呱叫 
{
	public:
		virtual void quack();
};
class Squeak:public QuackBehavior//吱吱叫 
{
	public:
		virtual void quack();
};
class MuteQuack:public QuackBehavior//不叫 
{
	public:
		virtual void quack();
}; 


#endif

<strong>//file:Behavior.cpp</strong>
#include <iostream>
#include "Behavior.h"
void FlywithWings::fly()
{
	std::cout<<"I'm flying!"<<std::endl;
} 

void FlynoWay::fly()
{
	std::cout<<"I can't fly!"<<std::endl;
}



void Quack::quack()
{
	std::cout<<"quack!"<<std::endl;
}

void Squeak::quack()
{
	std::cout<<"squack!"<<std::endl;
}

void MuteQuack::quack()
{
	std::cout<<"mutequack!"<<std::endl;
}

<strong>//file:Duck.h </strong>
#ifndef DUCK_H
#define DUCK_H

#include "Behavior.h"
class Duck//鴨子抽象類 
{
	protected://飛行和叫委託給行爲對象 ，行爲便於擴展 
		FlyBehavior *ptrFly;
		QuackBehavior *ptrQuack;
	public:
		void swim();
		virtual void display()=0;
		void performQuack();
		void performFly();
		void setFly(FlyBehavior *ptrFly);
		void setQuack(QuackBehavior *ptrQuack);
};

//兩種不同的鴨子實現 
class RedHeadDuck:public Duck
{
	public:
		RedHeadDuck();
		void display();
		virtual ~RedHeadDuck();
};

class RubberDuck:public Duck
{
	public:
		RubberDuck();
		void display();
		virtual ~RubberDuck();
};

#endif

<strong>//file:Duck.cpp</strong>
#include "Duck.h"
#include <iostream>

void Duck::swim()
{
	std::cout<<"I'm swimming!"<<std::endl;
}
void Duck::performQuack()
{
	ptrQuack->quack();
}
void Duck::performFly()
{
	ptrFly->fly();
}
void Duck::setFly(FlyBehavior *ptrFly)
{
	this->ptrFly=ptrFly;
}
void Duck::setQuack(QuackBehavior *ptrQuack)
{
	this->ptrQuack=ptrQuack;
}


void RedHeadDuck::display()
{
	std::cout<<"I'm RedHeadDuck!" <<std::endl;
}

RedHeadDuck::RedHeadDuck()
{
	ptrFly=new FlywithWings();
	ptrQuack=new Quack();
}

RedHeadDuck::~RedHeadDuck()
{
	delete ptrFly;
	delete ptrQuack;
}

void RubberDuck::display()
{
	std::cout<<"I'm RubberDuck!" <<std::endl;
}

RubberDuck::RubberDuck()
{
	ptrFly=new FlynoWay();
	ptrQuack=new Squeak();
}

RubberDuck::~RubberDuck()
{
	delete ptrFly;
	delete ptrQuack;
}

<strong>//file:main.cpp</strong>
#include <iostream>

#include "Duck.h"
/*不同的鴨子：
都會游泳；
展示不同的外表；
有的鴨子會飛，有的不會飛；
有的呱呱叫，有的吱吱叫，有的不會叫。*/



int main(int argc, char** argv) 
{
	Duck *duck1=new RedHeadDuck();
	duck1->display();
	duck1->swim();
	duck1->performFly();
	duck1->performQuack();
	duck1->setFly(new FlynoWay());//設置飛行方式，動態改變行爲 
	duck1->performFly();
	
	Duck *duck2=new RubberDuck();
	duck2->display();
	duck2->swim();
	duck2->performFly();
	duck2->performQuack();
	
	return 0;
}