策略者模式（代码实践C++/Java/Python）———

文章目录

1 设计目标
2 Java
- 2.1 涉及知识点
- 2.2 实现
- - 2.2.1 实现两个接口飞行为和叫行为
  - 2.2.2 实现Duck抽象基类（把行为接口作为类成员）
  - 2.2.3 实现接口飞行为和叫行为的具体行为
  - 2.2.4 具体实现鸭子
  - 2.2.5 模型调用
3 C++（用到了大量C++2.0的知识）
- 3.1 涉及知识点
- 3.2 实现
- - 3.2.1 实现飞行为和叫行为接口
  - 3.2.2 实现Duck基类（使用委托/组合，把指向抽象接口类的指针作为类成员）
  - 3.2.3 实现接口类的飞行为和叫行为
  - 3.2.4 实现具体的鸭子行为
  - 3.2.5 具体调用
4 Python实现
- 4.1 涉及知识点
- 4.2 实现代码
- - 4.2.1 实现两个接口飞行为和叫行为
  - 4.2.2 实现Duck抽象基类（把行为接口作为类成员）
  - 4.2.3 实现接口飞行为和叫行为的具体行为
  - 4.2.4 具体实现鸭子
  - 4.2.5 模型调用
5 完整代码
6 其他知识阅读（快速入门）

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{
    @Override
    public void fly(){
        System.out.println("I'm flying");
    }
}

public class FlyNoWay implements FlyBehavior{
    @Override
    public void fly() {
        System.out.println("I can't fly");
    }
}

public class FlyRocketPowered implements FlyBehavior{
    @Override
    public void fly() {
        System.out.println("I'm fly with rocket!");
    }
}

具体实现叫行为接口：

public class Quack implements QuackBehavior{
    @Override
    public void quack() {
        System.out.println("Quack");
    }
}

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

public class Squeak implements QuackBehavior{
    @Override
    public 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();
    }

    @Override
    public void display() {
        System.out.println("I'm a model duck");
    }
}

2.2.5 模型调用

public class Test {

    public static void main(String[] args) {
        //示例1
        Duck mallardDuck = new MallardDuck();
        mallardDuck.performQuack();
        mallardDuck.performFly();
        //示例2
        Duck 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):
    # 抽象方法
    @abstractmethod
    def fly(self):
        pass

class QuackBehavior(ABC):
    @abstractmethod
    def quack(self):
        pass

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

class Duck(ABC):
    def __init__(self, flyBehavior: FlyBehavior, quackBehavior: QuackBehavior) -> None:
        self._flyBehavior = flyBehavior
        self._quackBehavior = quackBehavior

    @abstractmethod
    def perform(self) -> None:
        pass

    def performFly(self) -> None:
        return self._flyBehavior.fly()

    def performQuack(self) -> None:
        return self._quackBehavior.quack()

    @property
    def flyBehavior(self) -> FlyBehavior:
        return self._flyBehavior

    @property
    def quackBehavior(self) -> QuackBehavior:
        return self._quackBehavior

    @flyBehavior.setter
    def flyBehavior(self, fly: FlyBehavior) -> None:
        self._flyBehavior = fly

    @quackBehavior.setter
    def quackBehavior(self, quack: QuackBehavior) -> None:
        self._quackBehavior = quack

    def 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 = quackBehavior

    def 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()