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

面向对象（精髓）变继承关系为组和关系（_Decorator模式）

news 2025/9/16 2:47:02

在这里插入图片描述

在软件开发中，设计模式是解决常见问题的可重用解决方案。在面向对象编程中，继承和组合是两种常用的代码复用方式。然而，随着软件需求的不断变化，我们需要更灵活的设计方式来应对不断变化的需求。在本文中，我们将讨论从继承到组合的演进之路，并探讨如何通过组合设计模式来解决问题。

假如：要实现同时记日志和事务提交如何做比较好

不推荐写法（继承关系）

继承设计的缺陷在于它限制了代码的扩展性和灵活性。具体来说，它导致了以下问题：
在上面的 UML 图中，我们展示了使用继承关系实现日志记录和事务管理的示例。在这个示例中，我们有一个抽象类 LoggingRunnable 和 TransactionalRunnable，它们都包含了一个抽象方法 doRun() 来执行具体的任务。然后，我们有一个具体的类 CodingTask，它继承自 LoggingRunnable 和 TransactionalRunnable，并实现了 doRun() 方法来执行编码任务。

现在，假设我们需要修改系统，让每个编码任务先记录日志，然后再进行事务管理。使用继承关系，我们需要在现有的类结构中进行大量的修改，这可能会导致代码变得复杂和难以维护。下面是一个示例代码，展示了在现有系统中添加事务管理的改动：

public abstract class LoggingTransactionalRunnable extends LoggingRunnable {private final Runnable innerRunnable;public LoggingTransactionalRunnable(Runnable innerRunnable) {this.innerRunnable = innerRunnable;}@Overridepublic void run() {super.run();beginTransaction();innerRunnable.run();commitTransaction();}private void beginTransaction() {// 开启事务}private void commitTransaction() {// 提交事务}
}

在这个示例中，我们创建了一个新的抽象类 LoggingTransactionalRunnable，它继承自 LoggingRunnable，并实现了事务管理的功能。然后，我们修改了 CodingTask 类，使其继承自 LoggingTransactionalRunnable，以实现先记录日志，然后执行编码任务，最后进行事务管理的功能。

尽管这种方法可以实现需求，但它会导致现有系统的大量修改，可能会破坏现有的代码结构，增加代码的复杂性和难以维护性。因此，使用继承关系来实现这种需求存在 类耦合度高， 单一继承限制，难以复用和测试可能不是最佳选择。

相对于继承关系，组合关系具有更低的耦合度和更高的灵活性。通过组合关系，可以将不同的功能模块化，并在运行时动态地组合它们，从而实现更灵活和可扩展的设计。因此，在设计类和对象时，应尽量避免过度使用继承关系，而是倾向于使用组合关系来实现代码的复用和扩展。

推荐写法（组合关系）

在这里插入图片描述
箭头表示实现关系和组合关系。其中 CodingTask、LoggingRunnable 和 TransactionalRunnable 类都实现了 Runnable 接口，表示它们都是可以在单独的线程中运行的任务。而 LoggingRunnable 和 TransactionalRunnable 类分别包含了一个 Runnable 类型的私有属性，表示它们与内部的任务对象发生了组合关系。
在这里插入图片描述

//LoggingRunnable.java
public class LoggingRunnable implements Runnable {private final Runnable runnable;public LoggingRunnable(Runnable innerRunnable) {this.runnable = innerRunnable;}@Overridepublic void run() {long startTime = System.currentTimeMillis();System.out.println("Task started at "+ startTime);//Decorator 模式是一种常见的设计模式，用于动态地为对象添加额外的功能，而不需要修改其原始类。runnable.run();System.out.println("Task finished. Elapsed time: "+ (System.currentTimeMillis() - startTime));}
}
// CodingTask.java
public class CodingTask implements Runnable {private final int employeeId;public CodingTask(int employeeId) {this.employeeId = employeeId;}@Overridepublic void run() {System.out.println("Employee " + employeeId+ " started writing code.");try {Thread.sleep(5000);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println("Employee " + employeeId+ " finished writing code.");}
}

上面的代码展示了使用组合关系实现的两个类：LoggingRunnable 和 CodingTask。

  1. LoggingRunnable 类：该类实现了 Runnable 接口，并包含了一个私有成员变量 runnable，类型为 Runnable 接口。在构造函数中，通过参数传入一个 Runnable 对象，然后在 run() 方法中，首先记录了任务开始的时间，然后调用传入的 Runnable 对象的 run() 方法执行具体的任务，最后记录了任务结束的时间。

  2. CodingTask 类：该类也实现了 Runnable 接口，表示一个编码任务。在 run() 方法中，它简单地打印出员工开始编写代码的消息，然后休眠 5 秒钟（模拟编写代码的过程），最后打印出员工编写代码完成的消息。

这两个类之间的关系是组合关系，即 LoggingRunnable 类包含一个 Runnable 接口的实例。通过这种组合关系，LoggingRunnable 类可以在执行任务前后添加额外的功能，而不需要修改 CodingTask 类的代码。这符合了开闭原则，即对扩展开放，对修改关闭。

功能扩展

如果有一天项目经理添加新需求事务和MQ 整合

对于组合设计模式，你可以想象一个新的扩展类，例如 MessagingTransactionalRunnable，它可以组合 TransactionalRunnable 和 MessagingRunnable 两个功能，从而实现事务管理和向 MQ 发送消息的组合。下面是一个简单的示例：
在这里插入图片描述

public class MessagingTransactionalRunnable implements Runnable {private final Runnable innerRunnable;private final String message;public MessagingTransactionalRunnable(Runnable innerRunnable, String message) {this.innerRunnable = innerRunnable;this.message = message;}@Overridepublic void run() {try {beginTransaction();sendMessage(message);innerRunnable.run();commit();} catch (Exception e) {rollback();throw new RuntimeException(e);}}private void sendMessage(String message) {System.out.println("Sending message to MQ: " + message);// 实现向 MQ 发送消息的逻辑}private void commit() {System.out.println("Commit transaction");// 实现事务提交的逻辑}private void rollback() {System.out.println("Rollback transaction");// 实现事务回滚的逻辑}private void beginTransaction() {System.out.println("Begin transaction");// 实现事务开始的逻辑}
}

在这个示例中，MessagingTransactionalRunnable 类组合了 TransactionalRunnable 和 MessagingRunnable 两个功能模块，通过调用它们的方法来实现事务管理和向 MQ 发送消息的组合。当 MessagingTransactionalRunnable 对象的 run 方法被调用时，它会先开始事务，然后发送消息到 MQ，执行内部的任务，最后提交或回滚事务。这样，你就可以很方便地使用组合设计模式来扩展功能了。

总结

继承的局限性

继承是面向对象编程中的一种重要概念，它允许子类继承父类的属性和方法。通过继承，可以实现代码的重用和扩展。然而，继承也存在一些局限性：

  • 耦合度高: 子类与父类之间存在紧密的耦合关系，子类的实现依赖于父类的具体实现细节。
  • 继承链过长: 当继承层次较深时，维护和理解代码变得困难，容易造成代码膨胀和复杂性增加。
  • 单一继承: 在单继承语言中，子类只能继承一个父类，限制了代码的灵活性和可复用性。

由于这些局限性，我们需要寻找一种更灵活的设计方式来解决问题。

组合的优势

组合是另一种常见的代码复用方式，它允许将对象组合在一起以实现新的功能。相比于继承，组合具有以下优势：

  • 低耦合度: 组合将对象之间的耦合度降低到最低限度，每个对象都可以独立存在并且可以被替换或重用。
  • 灵活性: 通过组合，可以动态地组合和重组对象以实现不同的功能，而不需要修改原始类的代码。
  • 多态性: 组合提倡面向接口编程，利用多态性来实现代码的灵活性和可扩展性。

扩展阅读

在这里插入图片描述

面向对象主题链接
类与对象链接
接口与抽象类链接
不可变性链接
变继承为组合（精髓一）状态模式链接
变继承为组合（精髓二）装饰器模式链接
http://www.lryc.cn/news/317813.html

相关文章：

  • MES系统在智能生产中的重要作用
  • 2024.3.13每日一题
  • YOLOv5 | 涨点复现！YOLOv5添加BiFPN有效提升目标检测精度
  • 【Nut3】nuxt.config.ts项目nuxt配置文件介绍
  • 区块链技术的革命性影响
  • 多线程(volatile)
  • 蓝桥杯 填空 卡片
  • ELK介绍使用
  • 【UE5】非持枪状态蹲姿移动的动画混合空间
  • Windows C++ TCP开发（使用select函数以及设置非阻塞/Reuse属性）
  • ARM TrustZone技术解析：构建嵌入式系统的安全扩展基石
  • 初识Python语言-课堂练习【pyhton123题库】
  • chrome高内存占用问题
  • 【C语言】文件操作篇-----程序文件和数据文件，文件的打开和关闭，二进制文件和文本文件，fopen，fclose【图文详解】
  • 知识碎片收集
  • 不可不知！用例图的绘制与应用全指南深度解析
  • 【数据结构七】堆与PriorityQueue详解
  • uniapp写支付的操作
  • 微信小程序开发系列（二十四）·wxml语法·列表渲染·wx:for-item 和 wx:for-index
  • 下载无水印抖音视频
  • L1-039 古风排版(C++)
  • springboot项目docker分层构建
  • 深入理解SPA、CSR与SSR的区别及应用
  • 基于电鳗觅食优化算法（Electric eel foraging optimization,EEFO）的无人机三维路径规划（提供MATLAB代码）
  • 将SQL数据库转换为Mysql数据库
  • Java集合进阶
  • 一.算法基础
  • python自学7
  • Umi - 刷新后页面报404
  • 图片编辑器tui-image-editor