头一回阅读《Head First 设计模式》，感觉语言生动形象，把一个个抽象的模式描述的浅显易懂，就像白话文一样。

正如作者推荐如何使用这本书。

你懂Java吗（不太懂... 会C++不影响吧）？  

你想学习、了解、记得并应用设计模式，以及其所基于的OO设计原则吗（是的，我正在深入学习C++呢）？

你是不是更喜欢一种轻松愉悦的学习环境（absolutely）？

这本书正是我需要的~   "Head First"就是那些不断学习的人们，像他们致敬，共勉加油~

使用设计模式最好的原则【把模式装进大脑里，然后在你的设计和原有的设计中，寻找使用他们的合适机会】

什么是设计模式？【过去的前辈们在设计OO时针对特定的一类对象积累下来的经验，值得我们学习和继承之】

                              模式不是代码，是一种通用的解决方案。用好来是善事。

------------------------------------------------ Strategy  ---------------------------------------------------

设计原则之一：【把变化的和不变的部分分开，不要把它们放在一块，将变化封装成接口】

设计原则之二：【针对接口编程，而不是实现编程】

可以将接口做成ABC(abstract base class)，具体的Implement实现代表不同的各种策略。

超类里有所有通用的不变的行为，其他继承它即可。

设计原则之三：【多用组合(composition)，少用继承(inherihence)】

【有一个HAS-A】可能比【是一个IS-A】更好。

【策略模式】定义了算法族(?针对同一对象的不同操作或者策略?)，将其分别封装起来，让它们之间可以相互替换，此模式让算法的变化独立于使用算法的客户。

然后自己用C++实现的鸭类，有疏漏的地方请指教：

<span style="font-family:Microsoft YaHei;"><span style="font-size:18px;"><span style="font-size:14px;">// StrategyPattern.h

// 抽象基类
class FlyBehavior
{
public:
	FlyBehavior();
	virtual ~FlyBehavior();
	virtual void Fly() = 0;  
};

class QuackBehavior
{
public:
	QuackBehavior();
	virtual ~QuackBehavior();
	virtual void Quack() = 0;
};

// 鸭子飞的行为
class FlyWithWings : public FlyBehavior
{
public:
    FlyWithWings();  
	~FlyWithWings(); 
	void Fly();
};

class FlyNoWing : public FlyBehavior
{
public:
	void Fly();
};

// 鸭子叫的行为
class QuackGua : public QuackBehavior
{
public:
	void Quack();
};

class Squeak : public QuackBehavior
{
public:
	void Quack();
};

class MuteQuack : public QuackBehavior
{
public:
	void Quack();
};


// 超类
class Duck
{
protected:
	FlyBehavior * m_flyBehavior;
	QuackBehavior * m_quackBahavior;

public:
	Duck();
	virtual ~Duck();  
	void Swim();
	virtual void Display();  
	void PerformFly();
	void PerformQuack();
	void SetFlyBehavior(FlyBehavior * flyBehavior);
	void SetQuackBehavior(QuackBehavior * quackBahavior);
};


class MallarDuck : public Duck
{
public:
	MallarDuck();
	virtual ~MallarDuck();  
	void Display();
};</span><span style="color: rgb(51, 0, 153); font-size: 18px;">
</span></span></span>

STRATEGY—跟不同类型的MM约会，要用不同的策略，有的请电影比较好，有的则去吃小吃效果不错，有的去海边浪漫最合适，单目的都是为了得到MM的芳心，我的追MM锦囊中有好多Strategy哦。

　　策略模式：策略模式针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。策略模式把行为和环境分开。环境类负责维持和查询行为类，各种算法在具体的策略类中提供。由于算法和环境独立开来，算法的增减，修改都不会影响到环境和客户端。

<span style="font-family:Microsoft YaHei;"><span style="font-size:18px;"><span style="font-size:14px;">// StrategyPattern.cpp

#include "StrategyPattern.h"

// 超类的实现
Duck::Duck()
{

}

Duck::~Duck()
{
	if(nullptr != flyBehavior)
	{
		delete flyBehavior;
	}
	if(nullptr != quackBehavior)
	{
		delete quackBehavior;
	}

	cout << "~Duck() implement" << endl;
}

void Duck::Swim()
{
	cout << "This duck can float..." << endl;
}

void Duck::Display()
{
	cout << "Duck::Display" << endl;
}

void Duck::PerformFly()
{
	m_flyBehavior->Fly();
}

void Duck::PerformQuack()
{
	m_quackBahavior->Quack();
}

void Duck::SetFlyBehavior(FlyBehavior * flyBehavior)
{
	m_flyBehavior = flyBehavior;
}

void Duck::SetQuackBehavior(QuackBehavior * quackBahavior)
{
	m_quackBahavior = quackBahavior;
}

// 玩具鸭子的实现
MallarDuck::MallarDuck()
{
	m_flyBehavior = new QuackGua;
	m_quackBahavior = new FlyWithWings;
}

MallarDuck::~MallarDuck()
{
	
}

void MallarDuck::Display()
{
	cout << "Display MallarDuck" << endl;
}

// 封装的接口实现
FlyBehavior::FlyBehavior()  
{  

}  

FlyBehavior::~FlyBehavior()  
{  
    cout << "~FlyBehavior()" << endl;  
}

void FlyWithWings::Fly()
{
	cout << "I can fly!!" << endl;
}

void FlyNoWay::fly()  
{  
	cout << "I can't fly..." << endl;  
} 


void QuackGua::quack()  
{  
	cout << "Quack Gua Gua ~~" << endl;  
}  
  
void Squeak::quack()  
{  
	cout << "Squeak Squeak ~~" << endl;  
}  

void MuteQuack::quack()  
{  
    cout << "I am  MuteQuack..." << endl;  
}  


int main(int argc,char* argv[])  
{  
    Duck * mallard = new MallarDuck();  

    mallard->display();  
    mallard->swim();  
    mallard->performQuack();  
    mallard->performFly();  
    mallard->setFlyBehavior(new FlyNoWay());  
    mallard->performFly();  

   	delete mallard;  

    return 0;  
} </span></span></span>

同理，在生活的很多其他地方也会用到【策略模式】，下面就是游戏中的一个例子，加深理解和印象！！

同样的Character是超类，King、Queue、Troll、Knight是继承超类的子类；WeaponBehavior是封装算法族的接口，KnifeBahavior、BowAndArrowBahavior、AxeBehavior和SwordBehavior是接口的四种实现策略。

转载请注明出处：http://blog.csdn.net/aall3210_tsingloon/article/details/27567915