用C++实现了书中的设计鸭子飞行的例子。
鸭子类设计
#ifndef DUCK_H_
#define DUCK_H_
#include<iostream>
#include"Fly.h"
#include"Quack.h"
using namespace std;
class Duck{
public:
Duck(){
}
void display();
void performFly(){
flyBehavior->fly();
}
void performQuack(){
quackBehavior->quack();
}
void swim()
{
std::cout << "All ducks float,even decoys!" << std::endl;
}
void setFlybehavior(FlyBehavior *fb){
flyBehavior = fb;
}
void setQuackbehavior(QuackBehavior *qb){
quackBehavior = qb;
}
FlyBehavior *flyBehavior;
QuackBehavior *quackBehavior;
};
飞行行为类设计
#ifndef FLY_H_
#define FLY_H_
#include<iostream>
class FlyBehavior{
public:
FlyBehavior(){
}
virtual void fly(){
};
};
class FLyWithwings : public FlyBehavior{
public:
void fly(){
std::cout << "I'am flying!" << std::endl;
}
};
class FlyNoway :public FlyBehavior{
public:
void fly(){
std::cout << "I can't fly!" << std::endl;
}
};
class FlywithRocket : public FlyBehavior{
public:
void fly(){
std::cout << "I'am flying with a rocket!" << std::endl;
}
};
#endif
叫声类设计
#ifndef QUACK_H_
#define QUACK_H_
#include<iostream>
class QuackBehavior{
public:
QuackBehavior(){
}
virtual void quack(){
};
};
class Quack :public QuackBehavior{
public:
void quack(){
std::cout << "Quack" << std::endl;
}
};
class MuteQuack :public QuackBehavior{
public:
void quack(){
std::cout << "<<Silence>>" << std::endl;
}
};
class Squack :public QuackBehavior{
public:
void quack(){
std::cout << "Squack" << std::endl;
}
};
#endif
主函数(测试函数)
#include"Duck.h"
#include"Fly.h"
#include"Quack.h"
#include<iostream>
int main()
{
Duck *mallard = new MallardDuck();
mallard->performFly();
mallard->performQuack();
Duck *model = new ModelDuck();
FlyBehavior *fb = new FlywithRocket();
model->setFlybehavior(fb);
model->performFly();
return 0;
}
运行结果:
策略模式设计原则:
1.找出应用中可能需要变化之处,把他们独立出来,不要和那些不需要变化的代码放在一起。如实现中将飞行方法类和叫声类从鸭子类分离出来,以满足以后出现新的鸭子行为。
2.针对接口编程,而不是针对实现编程。这句话我不是十分理解,可能就是飞行类和叫声类的基类作为接口,用派生类进行实现。
3.多用组合,少用继承。即不同的类之间的组合,由此建立的系统具有很大的弹性。
采用这种设计可以让飞行和呱呱叫的动作被其他对象复用,因为这些行为已经和鸭子类无关。如果我们新增一些行为如使用推进器飞行动作,不会影响到既有的行为类,也不会影响到使用飞行行为的鸭子类。
由以上可知,所谓策略模式,定义了算法族,并分别进行封装,让他们之间可以互相替换,此模式让算法的变化独立于使用算法的客户。