策略者模式（代码实践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{@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.hqwc.cn/news/616155.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

SAP CAP篇十七：写个ERP的会计系统吧，Part IV

SAP CAP篇十七：写个ERP的会计系统吧，Part IV

本文目录 本系列文章目标开发步骤数据库表设计借贷初始化数据 会计凭证 Service 定义生成Fiori App更新CDS AnnotationApp运行 本系列文章 SAP CAP篇一: 快速创建一个Service&#xff0c;基于Java的实现 SAP CAP篇二&#xff1a;为Service加上数据库支持 SAP CAP篇三&#xff…
阅读更多...
最新Zibll子比主题V7.1版本源码 全新推出开心版

最新Zibll子比主题V7.1版本源码 全新推出开心版

源码下载地址&#xff1a;Zibll子比主题V7.1.zip
阅读更多...
顺序表的基本操作

顺序表的基本操作

目录 命名规范 顺序表的定义 静态顺序表 动态顺序表 顺序表的基本操作 顺序表的初始化 顺序表的销毁 顺序表的打印 顺序表的容量检查 指定位置插入元素 指定位置删除元素 查找元素 在尾部添加一个元素 删除最后一个元素 在开头添加一个元素 删除首元素 命名规范…
阅读更多...
4、jvm-垃圾收集算法与垃圾收集器

4、jvm-垃圾收集算法与垃圾收集器

垃圾收集算法 分代收集理论 当前虚拟机的垃圾收集都采用分代收集算法&#xff0c;这种算法没有什么新的思想&#xff0c;只是根据对象存活周期的不同将内存分为几块。一般将java堆分为新生代和老年代&#xff0c;这样我们就可以根据各个年代的特点选择合适的垃圾收集算法。 比如…
阅读更多...
AI在运维实践中的价值提升

AI在运维实践中的价值提升

在2024年的AI赛道上&#xff0c;利用大数据 、机器学习算法、人工智能来改善运维效率已成为软件运营商发展的新主张&#xff0c;通过AI在运维流程的洞察、决策和执行&#xff0c;从而提升效率、减少故障时间&#xff0c;优化用户体验。通过分析大量数据来识别趋势和模式&#x…
阅读更多...
海山数据库（He3DB）原理剖析：浅析Doris跨源分析能力

海山数据库（He3DB）原理剖析：浅析Doris跨源分析能力

Doris湖仓分析背景&#xff1a; Doris多数据源功能演进 Doris的生态近年来围绕湖仓分析做了较多工作&#xff0c;Doris一直在积极拓宽大数据生态的OLAP分析市场&#xff0c;Doris2.0之后为了满足湖仓分析场景&#xff0c;围绕multi-catalog、数据缓存、容错、pipeline资源管理…
阅读更多...
Facebook广告投放数据API对接流程

Facebook广告投放数据API对接流程

说明&#xff1a;仅供学习使用&#xff0c;请勿用于非法用途&#xff0c;若有侵权&#xff0c;请联系博主删除 作者&#xff1a;zhu6201976 一、需求背景 App在Facebook、Google等巨头进行广告投放&#xff0c;想要拿到实时广告投放效果数据&#xff0c;如曝光、点击、花费、触…
阅读更多...
VM虚拟机Linux系统Redhat7.4版本进行网络配置

VM虚拟机Linux系统Redhat7.4版本进行网络配置

日常中自己搭建的虚拟机一般用到两种网络方式&#xff0c;第一种是仅主机模式、还有一种是NAT模式。 1、仅主机模式&#xff1a;可以和自己本地电脑&#xff0c;或者虚拟机和虚拟机之间进行网络通信&#xff0c;相当于一个局域网&#xff0c;是不能连接外网的。 2、NAT模式&a…
阅读更多...
26、链表-环形链表II

26、链表-环形链表II

思路&#xff1a; 这道题就是判断链表中是否有环&#xff0c;首先使用集合肯定可以快速地解决&#xff0c;比如通过一个set集合遍历&#xff0c;如果遍历过程中有节点在set中已经存在那么说明存在环。返回这个节点即可 第二种方式就是通过快慢指针方式寻找环。如何做呢&#xf…
阅读更多...
Unity 获取RenderTexture像素颜色值

Unity 获取RenderTexture像素颜色值

拿来吧你~ &#x1f9aa;功能介绍&#x1f32d;Demo &#x1f9aa;功能介绍 &#x1f4a1;不通过Texture2D 而是通过ComputerShader 提取到RenderTexture的像素值&#xff0c;效率有提升哦&#xff01; &#x1f4a1;通过扩展方法调用&#xff0c;方便快捷&#xff1a;xxxRT.G…
阅读更多...
DRF多表关联的序列化和反序列化

DRF多表关联的序列化和反序列化

DRF多表关联的序列化和反序列化 目录 DRF多表关联的序列化和反序列化序列化定制字段source一对多的序列化 多表关联的序列化方式1&#xff1a;在表模型中定义方法方式2&#xff1a;定制返回格式SerializerMethodField方式3&#xff1a;子序列化 多表关联的反序列化反序列化保存…
阅读更多...
安达发|电子行业智能生产排程计划的实施

安达发|电子行业智能生产排程计划的实施

随着科技的不断发展&#xff0c;电子行业正面临着巨大的变革。在这个过程中&#xff0c;智能生产排程计划的实施成为了提高生产效率、降低成本的关键因素。本文将详细介绍电子行业智能生产排程计划的实施方法、优势以及可能遇到的挑战。 一、实施方法 1. 数据采集与分析&#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023