当前位置： 首页 > news >正文

策略者模式（代码实践C++/Java/Python）————设计模式学习笔记

news 2025/7/20 9:34:56

文章目录

  • 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{@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

http://www.lryc.cn/news/340499.html

相关文章：

  • vue2/Vue3项目中，通过请求接口来刷新列表中的某个字段（如：Axios）
  • Java多线程锁定
  • 【C 数据结构】单链表
  • [MAUI]集成富文本编辑器Editor.js至.NET MAUI Blazor项目
  • Spring Boot | Spring Boot 整合 “Servlet三大组件“ ( Servlet / Filter / Listene )
  • 错误分析 （Machine Learning研习十九）
  • SQL系统函数知识点梳理（Oracle）
  • 面试突击---MySQL索引
  • 关注 | 我国已对百种产品实施强制性产品认证
  • 虚幻引擎架构自动化及蓝图编辑器高级开发进修班
  • Weakly Supervised Audio-Visual Violence Detection 论文阅读
  • 华为海思数字芯片设计笔试第六套
  • 重绘和重排：概念、区别和应用示例
  • 创建k8s deploy yaml文件的imagePullSecrets语句
  • 大模型预测结果导入到Doccano，人工修正预测不准的数据
  • python三方库_ciscoconfparse学习笔记
  • HDFS详解(Hadoop)
  • python创建word文档并向word中写数据
  • MongoDB的安装配置及使用
  • Go学习路线
  • 安全大脑与盲人摸象
  • 如何使用Git-Secrets防止将敏感信息意外上传至Git库
  • Day 14 网络协议
  • msyql中SQL 错误 [1118] [42000]: Row size too large (＞ 8126)
  • 实验六 智能手机互联网程序设计（微信程序方向）实验报告
  • Linux环境下，让Jar项目多线程部署成为可能
  • k8s调度场景
  • 基于小程序实现的餐饮外卖系统
  • 家居网购项目（手写分页）
  • goland2024安装包（亲测可用）