1 设计目标

此篇为实现篇下，如果对策略者模式不熟，可以看知识点篇上。

实现要求：鸭子共有三种行为，游泳行为（所有鸭子都会），飞行行为（能飞/不能飞/具有火箭动力的飞行），叫声行为（嘎嘎叫/吱吱叫/什么都不会叫），不同具体鸭子（绿头鸭/模型鸭/…）飞行行为和叫声行为可能不一样。

2 Java

2.1 涉及知识点

• 接口（interface）：定义一种方法约束
• 继承（extend）：子类会具有父类的一般特性也会具有自身的特性，提高代码复用性。

区别：

修饰符不同：接口使用interface修饰，继承使用extends修饰。
多继承方式不同：接口支持多继承，继承只支持单继承。
定义方式不同：接口只能定义全局常量和抽象方法，继承可以定义属性、方法、变量、常量等。
作用不同：接口是一种约束，类实现接口就一定要实现它所有的方法；继承是一种扩展，继承了类，它的私有成员以外的成员变量和成员方法子类都将拥有。

• 组合（委托）：把A类作为B类的成员变量，具体实现在A类中，B类对外暴露调用接口，解耦合。
• 抽象基类：不能实例化，只能作为类模版，子类需要实现起抽象方法。
• 构造函数：类的初始化方法。

2.2 实现

2.2.1 实现两个接口飞行为和叫行为

public interface FlyBehavior {public void fly();
}public interface QuackBehavior {public void quack();
}

2.2.2 实现Duck抽象基类（把行为接口作为类成员）

package com.jiangxue.strategy;public abstract class Duck {//组合（委托）：策略类作为抽象基类的成员变量QuackBehavior quackBehavior;FlyBehavior flyBehavior;//定义抽象方法：子类必须要实现public abstract void display();//调用类成员的方法public void performQuack(){quackBehavior.quack();;}public void performFly(){flyBehavior.fly();}//所有子类都有的共有行为public void swim(){System.out.println("All ducks float, even decoys");}//setter方法设置鸭子行为（运行时改变行为）public void setFlyBehavior(FlyBehavior fb){flyBehavior = fb;}public void setQuackBehavior(QuackBehavior quackBehavior) {this.quackBehavior = quackBehavior;}
}

2.2.3 实现接口飞行为和叫行为的具体行为

• 具体实现飞行为接口：

public class FlyWithWings implements FlyBehavior{@Overridepublic void fly(){System.out.println("I'm flying");}
}public class FlyNoWay implements FlyBehavior{@Overridepublic void fly() {System.out.println("I can't fly");}
}public class FlyRocketPowered implements FlyBehavior{@Overridepublic void fly() {System.out.println("I'm fly with rocket!");}
}

• 具体实现叫行为接口：

public class Quack implements QuackBehavior{@Overridepublic void quack() {System.out.println("Quack");}
}public class MuteQuack implements QuackBehavior{@Overridepublic void quack() {System.out.println("<<Silence>>");}
}public class Squeak implements QuackBehavior{@Overridepublic void quack() {System.out.println("Squack");}
}

2.2.4 具体实现鸭子

• 实现绿头鸭

public class MallardDuck extends Duck{//重新构造函数public MallardDuck(){quackBehavior = new Quack();flyBehavior = new FlyWithWings();}public void display(){System.out.println("I'm a real Mallard duck");}
}

• 实现模型鸭：

public class ModelDuck extends Duck{public ModelDuck(){flyBehavior = new FlyNoWay();quackBehavior = new Quack();}@Overridepublic void display() {System.out.println("I'm a model duck");}
}

2.2.5 模型调用

public class Test {public static void main(String[] args) {//示例1Duck mallardDuck = new MallardDuck();mallardDuck.performQuack();mallardDuck.performFly();//示例2Duck model = new ModelDuck();model.performFly();//改变飞行行为model.setFlyBehavior(new FlyRocketPowered());model.performFly();;    }
}

3 C++（用到了大量C++2.0的知识）

3.1 涉及知识点

• 纯虚函数（用于实现接口）【virtua和= 0】：在基类中声明的虚函数，它在基类中没有定义，但要求任何派生类都要定义自己的实现方法。有纯虚函数的类是抽象类，不能生成对象，只能派生。
• virtual析构函数：当父类指针指向子类对象时，执行释放操作，子类对象也会被释放掉。
• explicit：该构造函数只能显式调用，禁止隐式转换。
• &&（右值引用）：结合了移动语义和完美转发；可以绑定到临时对象。
  • 移动语义：不复制对象，而只是让新的对象名指向原对象名所指对象，并且将原对象所指的置空。
  • 完美转发：可以撰写接受任意参数的函数模版，并将其转发到其他函数，目标函数会接受与其转发函数所接受的完全相同的参数。
• std::move（把实参强制转换为右值）:无条件地右值类型的强制类型转换；
• std::forward：仅对绑定到右值的引用实施向右值类型的强制转换。
  • 针对右值引用实施std::move，万能引用实施std::forward
• 智能指针unique_ptr：独占对象，不允许复制；动态管理分配对象的生命周期。
• make_unique函数：动态分配指定类型的内存，并返回一个指向分配内存的唯一指针。
• 子类继承父类的构造：不能直接从初始化列表初始化基类成员，应该使用父类的构造函数。
• 公有继承：基类的公有成员和保护成员的访问属性在派生类中不变

3.2 实现

3.2.1 实现飞行为和叫行为接口

class QuackBehavior{
public://纯虚函数只有函数的名字而不具备函数的功能，不能被调用，要求任何派生类都要定义自己的实现方法//有纯虚函数的类是抽象类，不能生成对象，只能派生。virtual void quack() const = 0;//virtual析构函数好处：当父类指针指向子类对象时，执行释放操作，子类对象也会被释放掉virtual ~QuackBehavior() =default;
};class FlyBehavior{
public:virtual void fly() const = 0;virtual ~FlyBehavior() = default;
};

3.2.2 实现Duck基类（使用委托/组合，把指向抽象接口类的指针作为类成员）

#include <memory>
#include "FlyBehavior.h"
#include "QuackBehavior.h"
#include <iostream>class Duck {
protected://智能指针unique_ptr：独占对象，不允许复制；动态管理分配对象的生命周期std::unique_ptr<FlyBehavior> _flyBehavior;std::unique_ptr<QuackBehavior> _quackBehavior;
public://explicit表示该构造函数只能显式调用，禁止隐式转换。/** 移动语义：不复制对象，而只是让新的对象名指向原对象名所指对象，并且将原对象所指的置空。* 完美转发：可以撰写接受任意参数的函数模版，并将其转发到其他函数，目标函数会接受与其转发函数所接受的完全相同的参数。* &&（右值引用）：结合了移动语义和完美转发；可以绑定到临时对象。* std::move（把实参强制转换为右值）:无条件地右值类型的强制类型转换；* std::forward：仅对绑定到右值的引用实施向右值类型的强制转换。* 针对右值引用实施std::move，万能引用实施std::forward*/explicit Duck(std::unique_ptr<FlyBehavior> &&flyBehavior ={},std::unique_ptr<QuackBehavior> &&quackBehavior={}):_flyBehavior(std::move(flyBehavior)),_quackBehavior(std::move(quackBehavior)){}//上下文允许在运行时替换策略对象。void setFlyBehavior(std::unique_ptr<FlyBehavior>&&flyBehavior){_flyBehavior = std::move(flyBehavior);}void setQuackBehavior(std::unique_ptr<QuackBehavior>&&quackBehavior){_quackBehavior = std::move(quackBehavior);}//执行飞void performFly() const{_flyBehavior->fly();}//执行叫void performQuack() const{_quackBehavior->quack();}void swim() const{std::cout<<"All ducks float, even decoys"<<std::endl;}virtual void display() const = 0;};

3.2.3 实现接口类的飞行为和叫行为

• 实现飞行为：

#include <iostream>
#include "FlyBehavior.h"//公有继承：基类的公有成员和保护成员的访问属性在派生类中不变
class FlyWithWings: public FlyBehavior{
public:void fly() const override{std::cout<<"I'm flying"<<std::endl;}
};class FlyNoWay: public FlyBehavior{
public:void fly() const override{std::cout<<"I can't fly"<<std::endl;}
};class FlyRocketPowered : public FlyBehavior{
public:void fly() const override{std::cout<<"I'm fly with rocket!"<<std::endl;}
};

• 实现叫行为：

#include "QuackBehavior.h"
#include <iostream>class Quack: public QuackBehavior{void quack() const override{std::cout<<"quack"<<std::endl;}
};class MuteQuack : public QuackBehavior{
public:void quack() const override{std::cout<<"<<Silence>>"<<std::endl;}
};class Squeak: public QuackBehavior{void quack() const override{std::cout<<"Squack"<<std::endl;}
};

3.2.4 实现具体的鸭子行为

• 绿头鸭

#include "Duck.h"
#include "Quack.h"
#include "FlyWithWings.h"
#include <iostream>class MallardDuck : public Duck{
public://子类继承父类的构造//不能直接从初始化列表初始化基类成员，应该使用父类的构造函数explicit MallardDuck(std::unique_ptr<FlyWithWings>&& flyWithWings ={},std::unique_ptr<Quack>&& quack={}): Duck(std::move(flyWithWings), std::move(quack)){}//虚函数方法重写void display() const override{std::cout<<"I'm a real Mallard duck"<<std::endl;}};

• 模型鸭

#include "Duck.h"
#include "FlyNoWay.h"
#include "Quack.h"class ModelDuck :public Duck{
public:explicit ModelDuck(std::unique_ptr<FlyNoWay>&& flyNoWay,std::unique_ptr<Quack>&& quack): Duck(std::move(flyNoWay), std::move(quack)){}void display() const override{std::cout<<"I'm a model duck"<<std::endl;}};

3.2.5 具体调用

#include "MallardDuck.h"
#include "ModelDuck.h"
#include "FlyRocketPowered.h"void testCode() {//make_unique函数：动态分配指定类型的内存，并返回一个指向分配内存的唯一指针MallardDuck mallardDuck(std::make_unique<FlyWithWings>(),std::make_unique<Quack>());mallardDuck.performQuack();mallardDuck.performFly();ModelDuck modelDuck(std::make_unique<FlyNoWay>(),std::make_unique<Quack>());modelDuck.performFly();modelDuck.setFlyBehavior(std::make_unique<FlyRocketPowered>());modelDuck.performFly();}int main() {testCode();return 0;
}

4 Python实现

4.1 涉及知识点

• 抽象基类（继承ABC）：不能被实例化，只能被继承。
• 抽象方法（@abstractmethod）：继承的子类必须实现的方法。
• 属性（@property，@flyBehavior.setter）：调用时不需要加()，为的是提供更加友好访问类数据的方式。
• 构造函数（def __init__）：初始化类成员变量。
• 继承（super().__init__）：继承父类的属性。
• from __future__ import annotations:允许你在程序中声明变量或函数的类型，并由编译器或其他工具来检查代码的类型是否正确。有助于提高代码的可读性，并且有助于发现类型错误。

4.2 实现代码

4.2.1 实现两个接口飞行为和叫行为

from abc import ABC, abstractmethod# 抽象基类
class FlyBehavior(ABC):# 抽象方法@abstractmethoddef fly(self):passclass QuackBehavior(ABC):@abstractmethoddef quack(self):pass

4.2.2 实现Duck抽象基类（把行为接口作为类成员）

class Duck(ABC):def __init__(self, flyBehavior: FlyBehavior, quackBehavior: QuackBehavior) -> None:self._flyBehavior = flyBehaviorself._quackBehavior = quackBehavior@abstractmethoddef perform(self) -> None:passdef performFly(self) -> None:return self._flyBehavior.fly()def performQuack(self) -> None:return self._quackBehavior.quack()@propertydef flyBehavior(self) -> FlyBehavior:return self._flyBehavior@propertydef quackBehavior(self) -> QuackBehavior:return self._quackBehavior@flyBehavior.setterdef flyBehavior(self, fly: FlyBehavior) -> None:self._flyBehavior = fly@quackBehavior.setterdef quackBehavior(self, quack: QuackBehavior) -> None:self._quackBehavior = quackdef swim(self) -> None:print("All ducks float, even decoys")

4.2.3 实现接口飞行为和叫行为的具体行为

• 具体实现飞行为接口：

class FlyWithWings(FlyBehavior):def fly(self) -> None:print("I'm flying")class FlyNoWay(FlyBehavior):def fly(self) -> None:print("I can't fly")class FlyRocketPowered(FlyBehavior):def fly(self) -> None:print("I'm fly with rocket!")

• 具体实现叫行为接口：

class Quack(QuackBehavior):def quack(self) -> None:print("Quack")class Square(QuackBehavior):def quack(self) -> None:print("Squack")class MuteQuack(QuackBehavior):def quack(self) -> None:print("<<Silence>>")

4.2.4 具体实现鸭子

• 实现绿头鸭

class ModelDuck(Duck):def __init__(self, flyBehavior: FlyNoWay, quackBehavior: Quack) -> None:super().__init__(flyBehavior, quackBehavior)# 下面的初始化方法，并不能继承父类的属性# _flyBehavior = flyBehavior# _quackBehavior = quackBehaviordef perform(self) -> None:print("I'm a model duck")

• 实现模型鸭：

class MallardDuck(Duck):def __int__(self, flyBehavior: FlyWithWings, quackBehavior: Quack) -> None:super().__init__(flyBehavior, quackBehavior)def perform(self) -> None:print("I'm a real Mallard duck")

4.2.5 模型调用

# import sys , os
# base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# sys.path.append(base_dir)
# 没有把当前项目加入到PYTHONPATH环境变量from Strategy.duck import *if __name__ == "__main__":mallardDuck = MallardDuck(FlyWithWings(), Quack())mallardDuck.performQuack()mallardDuck.performFly()modelDuck = ModelDuck(FlyNoWay(), Quack())modelDuck.performFly()modelDuck.flyBehavior = FlyRocketPowered()modelDuck.performFly()

5 完整代码

完整的实现代码，见Gitee仓库。如果对您有用的话，欢迎留下star，谢谢。

6 其他知识阅读（快速入门）

Java快速入门
Python快速入门
深入了解C++2.0