《Head First设计模式》之策略模式

设计模式原则总结

封装变化：找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。

少用组合，多用继承。

针对接口编程，而不是针对实现编程

策略模式定义：

将对象中的某些行为特征（算法簇）封装起来，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的客户对象。

以鸭子的飞行行为举例，假设有很多的飞行方式，将飞行行为封装为行为类，可以随意替换行为类。

鸭子类：

#include "FlyBehavior.h"
//鸭子基类
class CDuck
{
private:

public:
	CFlyBehavior* flybehavior;
	CDuck()
	{
		flybehavior = NULL;
	}
	~CDuck(){}
	void performFly()
	{
		flybehavior->fly();
	}
	virtual void display() = 0;
	void setFlyBehavior(CFlyBehavior *fb)
	{
		flybehavior = fb;
	}
};
//鸭子子类
class CMallardDuck :public  CDuck
{
public:
	CMallardDuck()
	{
		if (NULL != flybehavior)
		{
			delete flybehavior;
		}
			flybehavior = new CFlyWithWings;
	}
	~CMallardDuck()
	{
		delete flybehavior;
	}
	void display()
	{
		std::cout << "I'm a Mallard duck !"<< std::endl;
	}
};
//另一个鸭子子类
class CModelDuck :public  CDuck
{
public:
	CModelDuck()
	{
		if (NULL != flybehavior)
		{
			delete flybehavior;
		}
		flybehavior = new CFlyNoWay;
	}
	~CModelDuck()
	{
		delete flybehavior;
	}
	void display()
	{
		std::cout << "I'm a Model duck !" << std::endl;
	}
};

鸭子行为类

#ifndef _FLYBEHAVIOR_
#define _FLYBEHAVIOR_
#include <iostream>
//行为基类
class CFlyBehavior
{
public:
	virtual void  fly() = 0;
};
//行为类 用翅膀飞
class CFlyWithWings :public CFlyBehavior
{
	void fly()
	{
		std::cout <<"I'm flying with wings !"<< std::endl;
	}
};
//行为类 不能飞
class CFlyNoWay :public CFlyBehavior
{
	void fly()
	{
		std::cout << "I can't fly!" << std::endl;
	}
};
//行为类 利用火箭飞
class CFlyRocketPowered :public CFlyBehavior
{
	void fly()
	{
		std::cout << "I'm flying with a rocket !" << std::endl;
	}
};
#endif _FLYBEHAVIOR_

测试代码

#include "Duck.h"
#include "FlyBehavior.h"

int main()
{
	CDuck *mallard = new CMallardDuck;//行为类是 用翅膀飞
	mallard->display();
	mallard->performFly();


	CDuck *model = new CModelDuck;//行为类是 不能飞 
	model->display();
	model->performFly();
	std::cout <<"change behavior" << std::endl;
	model->setFlyBehavior(new CFlyRocketPowered);//替换行为类 利用火箭飞
	model->performFly();

	delete mallard;
	delete model;
	system("pause");
}

结果：