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

书上的例子是鸭子，参考blog的例子是缓存算法。参考blog见：https://blog.csdn.net/wuzhekai1985/article/details/6665197

鸭子：

class FlyBehavior {
public:
virtual void fly() {};
};

class FlyWithWings : public FlyBehavior {
public:
void fly() {
std::cout<<"Fly With Wings"<<std::endl;
}
};

class FlyNoWay : public FlyBehavior {
public:
void fly() {
std::cout<<"Cannot Fly"<<std::endl;
}
};

class QuackBehavior {
public:
virtual void quack() {};
};

class Quack : public QuackBehavior {
public:
void quack() {
std::cout<<"Quack"<<std::endl;
}
};

class Squeak : public QuackBehavior {
public:
void quack() {
std::cout<<"Squeak"<<std::endl;
}
};

class MuteQuack : public QuackBehavior {
public:
void quack() {
std::cout<<"Mute"<<std::endl;
}
};

class Duck {
public:
Duck() : flyBehavior(nullptr), quackBehavior(nullptr) {};
void fly() {
flyBehavior->fly();
}
void quack() {
quackBehavior->quack();
}

protected:
FlyBehavior* flyBehavior;
QuackBehavior* quackBehavior;
};

class MallardDuck : public Duck{
public:
MallardDuck () {
flyBehavior = new FlyWithWings;
quackBehavior = new Quack;
}
~MallardDuck() {
delete flyBehavior;
delete quackBehavior;
}
};

跟java相比的不同主要在于：

1. 对于封装的算法的父类型，在作为类成员的时候，要定义为指针。

2. 其实这条跟java关系不大。就是类成员变量有指针的时候，需要自己实现析构函数。

跟参考blog的算法的实现区别在于：

1. 参考blog的算法，构造函数需要传入一个表明类型和算法实现的参数。鸭子这个例子中，不同的鸭子集成鸭子父类，然后在子类的构造函数中初始化父类成员指针。