1.策略模式

模拟鸭子应用

需求

• 游戏中会出现各种鸭子，一边游泳戏水，一边呱呱叫。

一开始，是通过使用继承的方式，用派生类实现各种鸭子。

class Duck {
public:
    void quack();
    void swim();
    void display();
};

class MallardDuck : Duck {
public:
    void display() {
        // 外观是绿头
    }
};

class RedheadDuck {
    void display() {
        // 外观是红头
    }
};

以上缺点：

• 代码在多个子类中重复；
• 运行时的行为不容易改变；
• 我们不能让鸭子跳舞；
• 很难知道所有鸭子的全部行为；
• 鸭子不能同是又飞又叫；
• 改变会牵一发动全身，造成其他鸭子不想要的改变。

由于需求总在变化，现在我们需要让鸭子能飞起来。不同的鸭子，叫声、显示、飞行方式都可能不太一样。

面对这种情况，我们需要的是将不变的部分放在基类中，而将经常变化的部分分离出来，作为独立的部分进行封装。为此，我们做了以下工作：

• 利用抽象类（接口）代表每个行为，比如说FlyBehavior和QuackBehavior，而行为的每个实现都将实现其中的一个抽象类。
• 鸭子的子类将使用抽象类（FlyBehavior与QuackBehavior）所表示的行为，所以实际的“实现”不会被绑死在鸭子的子类中。
• 此次使用的是组合方式，而不是继承的方式进行实现。

于是代码变成了如下：

// 定义飞行行为抽象类（接口），
// 将鸭子类中经常变化的部分进行分离与封装。
class FlyBehavior {
public:
    virtual void fly() = 0;
    
    // 该类为基类，是需要被继承的。
    // 因此，析构函数需要被写成虚函数形式，
    // 这样子资源才得以正确释放。
    virtual ~FlyBehavior() {};
};

// 使用飞行行为抽象类（接口），
// 实现用翅膀飞行的具体类，
// 为下面继承鸭子基类的派生类复用和灵活设定使用类而使用。
class FlyWithWings : public FlyBehavior {
public:
    virtual void fly() {
        cout << "Fly with wings." << endl;
    }
};

// 使用飞行行为抽象类（接口），
// 实现没有飞行的具体类，
// 为下面继承鸭子基类的派生类复用和灵活设定使用类而使用。
class FlyNoWay : public FlyBehavior {
public:
    virtual void fly() {
        cout << "FlyNoWay: 啥时都不干。" << endl;
    }
};

// 定义鸭叫行为抽象类（接口），
// 将鸭子类中经常变化的部分进行分离与封装。
class QuackBehavior {
public:
    virtual void quack() = 0;
    
    // 该类为基类，是需要被继承的。
    // 因此，析构函数需要被写成虚函数形式，
    // 这样子资源才得以正确释放。
    virtual ~QuackBehavior() {};
};

// 使用鸭叫行为抽象类（接口），
// 实现鸭的呱呱叫具体类，
// 为下面继承鸭子基类的派生类复用和灵活设定使用类而使用。
class Quack : public QuackBehavior {
public:
    virtual void quack() {
        cout << "Quack quack..." << endl;
    }
};

// 使用鸭叫行为抽象类（接口），
// 实现鸭的唧唧叫具体类，
// 为下面继承鸭子基类的派生类复用和灵活设定使用类而使用。
class Squeak : public QuackBehavior {
public:
    virtual void quack() {
        cout << "Squeak squeak..." << endl;
    }
};

// 使用鸭叫行为抽象类（接口），
// 实现鸭的哑叫（不叫）具体类，
// 为下面继承鸭子基类的派生类复用和灵活设定使用类而使用。
class MuteQuack : public QuackBehavior {
public:
    virtual void quack() {
        cout << "mute quack..." << endl;
    }
};


// 鸭子作为具体基类，为后面各种鸭子的派生类做基础。
// 鸭子之所以作为基类而不是抽象类（接口），
// 是因为鸭子本身有具体的部分。
// 将鸭子的叫、飞行等方式通过组合的形式，而不是继承的方式实现，
// 可以获得在运行中动态改变，也实现了代码的最大化复用。
// 也不会出现引起继承所造成的牵一发动全身的缺点。
// 将不变的部分封装在基类即可。
class Duck {
public:
    Duck() {
        quackBehavior = nullptr;
        flyBehavior = nullptr;
    }

    // 该类为基类，是需要被继承的。
    // 因此，析构函数需要被写成虚函数形式，
    // 这样子资源才得以正确释放。
    virtual ~Duck() {};

    // 将鸭叫行为委托给行为类实现，
    // 实现类中经常变化的部分分离，得以封装。
    // 也实现了将变化的代码最大化的复用与灵活性。
    void performQuack() {
        quackBehavior->quack();
    };

    // 将飞行行为委托给行为类实现，
    // 实现类中经常变化的部分分离，得以封装。
    // 也实现了将变化的代码最大化的复用与灵活性。
    void performFly() {
        flyBehavior->fly();
    };

    virtual void display() {
        cout << "Duck display" << endl;
    }

    // 获得该类的鸭叫行为类
    const QuackBehavior const* getQuackBehavior() {
        return quackBehavior;
    }

    // 获得该类的飞行行为类
    const FlyBehavior const* getFlyBehavior() {
        return flyBehavior;
    }

    // 设置该类的鸭叫行为类
    void setQuackBehavior(QuackBehavior* quack) {
        delete quackBehavior;
        quackBehavior = quack;
    }

    // 设置该类的飞行行为类
    void setFlyBehavior(FlyBehavior* fly) {
        delete flyBehavior;
        flyBehavior = fly;
    }

// 类成员使用保护方式，将实现派生类可以访问该类成员，
// 实现该类在具体运行过程中可以动态改变行为。
protected:
    QuackBehavior* quackBehavior;
    FlyBehavior* flyBehavior;
};

class MallardDuck : public Duck {
public:
    // 初始化派生类的行为类
    MallardDuck() {
        quackBehavior = new Quack;
        flyBehavior = new FlyWithWings;
    }

    // 释放派生类所拥有的资源
    virtual ~MallardDuck() {
        delete quackBehavior;
        delete flyBehavior;
    }

    // 实现派生类的显示
    virtual void display() {
        cout << "MallardDuck display..." << endl;
    }
};

class RedHeadDuck : public Duck {
public:
    // 初始化派生类的行为类
    RedHeadDuck() {
        quackBehavior = new Squeak;
        flyBehavior = new FlyNoWay;
    }

    // 释放派生类所拥有的资源
    virtual ~RedHeadDuck() {
        delete quackBehavior;
        delete flyBehavior;
    }

    // 实现派生类的显示
    virtual void display() {
        cout << "RedHeadDuck display..." << endl;
    }
};