程序员经验分享-hwhale

依赖倒置原则——面向对象设计原则

2023-05-16

前两节我们详细介绍了面向对象设计原则中的开闭原则和里氏替换原则，在本节中我们来介绍依赖倒置原则。

依赖倒置原则的定义

依赖倒置原则（Dependence Inversion Principle，DIP）是 Object Mentor 公司总裁罗伯特·马丁（Robert C.Martin）于 1996 年在 C++ Report 上发表的文章。

依赖倒置原则的原始定义为：高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象（High level modules shouldnot depend upon low level modules.Both should depend upon abstractions.Abstractions should not depend upon details. Details should depend upon abstractions）。其核心思想是：要面向接口编程，不要面向实现编程。

依赖倒置原则是实现开闭原则的重要途径之一，它降低了客户与实现模块之间的耦合。

由于在软件设计中，细节具有多变性，而抽象层则相对稳定，因此以抽象为基础搭建起来的架构要比以细节为基础搭建起来的架构要稳定得多。这里的抽象指的是接口或者抽象类，而细节是指具体的实现类。

使用接口或者抽象类的目的是制定好规范和契约，而不去涉及任何具体的操作，把展现细节的任务交给它们的实现类去完成。

依赖、倒置原则的作用

依赖倒置原则的主要作用如下。

  • 依赖倒置原则可以降低类间的耦合性。
  • 依赖倒置原则可以提高系统的稳定性。
  • 依赖倒置原则可以减少并行开发引起的风险。
  • 依赖倒置原则可以提高代码的可读性和可维护性。

依赖倒置原则的实现方法

依赖倒置原则的目的是通过要面向接口的编程来降低类间的耦合性，所以我们在实际编程中只要遵循以下4点，就能在项目中满足这个规则。

  1. 每个类尽量提供接口或抽象类，或者两者都具备。
  2. 变量的声明类型尽量是接口或者是抽象类。
  3. 任何类都不应该从具体类派生。
  4. 使用继承时尽量遵循里氏替换原则。

下面以“顾客购物程序”为例来说明依赖倒置原则的应用。

【例1】依赖倒置原则在“顾客购物程序”中的应用。

分析：本程序反映了 “顾客类”与“商店类”的关系。商店类中有 sell() 方法，顾客类通过该方法购物以下代码定义了顾客类通过韶关网店 ShaoguanShop 购物：

class Customer {
    public void shopping(ShaoguanShop shop) {
        //购物
        System.out.println(shop.sell());
    }
}

但是，这种设计存在缺点，如果该顾客想从另外一家商店（如婺源网店 WuyuanShop）购物，就要将该顾客的代码修改如下：

class Customer {
    public void shopping(WuyuanShop shop) {
        //购物
        System.out.println(shop.sell());
    }
}

顾客每更换一家商店，都要修改一次代码，这明显违背了开闭原则。存在以上缺点的原因是：顾客类设计时同具体的商店类绑定了，这违背了依赖倒置原则。解决方法是：定义“婺源网店”和“韶关网店”的共同接口 Shop，顾客类面向该接口编程，其代码修改如下：

class Customer {
    public void shopping(Shop shop) {
        //购物
        System.out.println(shop.sell());
    }
}

这样，不管顾客类 Customer 访问什么商店，或者增加新的商店，都不需要修改原有代码了，其类图如图 1 所示。

顾客购物程序的类图
图1 顾客购物程序的类图

程序代码如下：

package principle;
public class DIPtest {
    public static void main(String[] args) {
        Customer wang = new Customer();
        System.out.println("顾客购买以下商品：");
        wang.shopping(new ShaoguanShop());
        wang.shopping(new WuyuanShop());
    }
}
//商店
interface Shop {
    public String sell(); //卖
}
//韶关网店
class ShaoguanShop implements Shop {
    public String sell() {
        return "韶关土特产：香菇、木耳……";
    }
}
//婺源网店
class WuyuanShop implements Shop {
    public String sell() {
        return "婺源土特产：绿茶、酒糟鱼……";
    }
}
//顾客
class Customer {
    public void shopping(Shop shop) {
        //购物
        System.out.println(shop.sell());
    }
}

程序的运行结果如下：

顾客购买以下商品：
韶关土特产：香菇、木耳……
婺源土特产：绿茶、酒糟鱼……

进阶阅读

如果您想了解依赖倒置原则在实际项目中的应用，可以猛击阅读《使用依赖倒置原则解决实际问题》文章。

使用依赖倒置原则解决实际问题

下面来看一个实例，以 C语言中文网的教程为例，首先创建一个学员类 ZhangSan。

package net.biancheng.c.dip;
public class ZhangSan {
    public void studyJava() {
        System.out.println("张三正在学习Java教程");
    }
    public void studyCplus() {
        System.out.println("张三正在学习C++教程");
    }
}

然后编写客户端测试代码并调用。

public static void main(String[] args) {
    ZhangSan zhangSan = new ZhangSan();
    zhangSan.studyJava();
    zhangSan.studyCplus();
}

目前张三正在学习 Java 和 C++ 教程，随着学习兴趣的暴涨，张三还想学习 Python 教程。这时就需要业务扩展，代码需要从底层开始修改，即：在 ZhangSan 类中添加 studyPython() 的方法，在高层（这里指的是 main() 方法）也要追加调用该方法。这样发布系统，实际上是非常不稳定的，在修改代码的同时会带来意想不到的风险。

下面我们优化代码，首先创建教程的抽象接口 Course。

package net.biancheng.c.dip;
public interface Course {
    void study();
}

然后编写 JavaCourse 类。

package net.biancheng.c.dip;
public class JavaCourse implements Course {
    @Override
    public void study() {
        System.out.println("张三在学习Java教程");
    }
}

同样，编写 CplusCourse 类。

package net.biancheng.c.dip;
public class CplusCourse implements Course {
    @Override
    public void study() {
        System.out.println("张三在学习C++教程");
    }
}

最后修改 ZhangSan 类。

public class ZhangSan {
    public void study(Course course) {
        course.study();
    }
}

客户端测试代码如下。

public static void main(String[] args) {
    ZhangSan zhangSan = new ZhangSan();
    zhangSan.study(new JavaCourse());
    zhangSan.study(new CplusCourse());
}

这个时候再看代码，无论张三要学习什么新教程，只需要建一个类，通过传参的方式告诉 ZhangSan 即可，而不需要修改底层代码。有的小伙伴可能已经发现了，这是大家非常熟悉的依赖注入。

注入的方式还有构造方法注入和 Setter 注入。下面来看构造方法注入。

public class ZhangSan {
    private Course course;
    public ZhangSan(Course course) {
        this.course = course;
    }
    public void study(Course course) {
        course.study();
    }
}

客户端代码如下，将 JavaCourse 对象作为 ZhangSan 对象的构造参数注入。

public static void main(String[] args) {
    ZhangSan zhangSan = new ZhangSan(new JavaCourse());
    zhangSan.study();
}

根据构造方法注入，调用时每次都要创建实例。如果 ZhangSan 是全局单例，只能选择 Setter 注入方式，继续修改 ZhangSan 类的代码。

package net.biancheng.c.dip;
public class ZhangSan {
    private Course course;
    public void setCourse(Course course) {
        this.course = course;
    }
    public void study() {
        course.study();
    }
}

来看客户端代码，调用 ZhangSan 对象的 setCourse() 方法，将 JavaCourse 对象作为参数。

public static void main(String[] args) {
    ZhangSan zhangSan = new ZhangSan();
    zhangSan.setCourse(new JavaCourse());
    zhangSan.study();
    zhangSan.setCourse(new CplusCourse());
    zhangSan.study();
}

最终得到的类图如下。

类图

转载于：http://c.biancheng.net/design_pattern/

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

依赖倒置原则

面向对象设计原则

依赖倒置原则——面向对象设计原则 的相关文章

随机推荐

  • C语言类型转换-自动类型转换、强制类型转换、指针类型转换

    数据类型转换就是将数据 xff08 变量 数值 表达式的结果等 xff09 从一种类型转换为另一种类型 自动类型转换 自动类型转换就是编译器默默地 隐式地 偷偷地进行的数据类型转换 xff0c 这种转换不需要程序员干预 xff0c 会自动发

  • 【C/C++开源库】适合嵌入式的定时器调度器

    一 背景 在嵌入式软件中 xff0c 我们经常需要使用定时功能 xff0c 比如每1s执行某个功能 xff0c 比如触发了某个条件之后持续1s 如果每次遇到定时的功能 xff0c 我们都自己去计数 xff0c 这会让我们的代码很混乱 xff

  • 【C/C++开源库】环形队列，消息队列库

    一 环形队列库 之前介绍过一个环形缓冲库 xff1a C语言开源库 在CLion上使用一个轻量的适合嵌入式系统的环形缓冲库ring buffer 和C语言Unity单元测试框架 环形缓冲库的设置是非常灵活的 xff0c 可以根据实际项目的需

  • QT学习Github地址，git使用记录

    QT学习 之前有一些QT的文章 xff1a QT5基础教程 xff08 介绍 xff0c 下载 xff0c 安装 xff0c 第一个QT程序 xff09 上位机总结 这次我把之前学习过程中的一些QT项目上传到github了 xff0c 有需

  • 探索Android中的Parcel机制（上）

    一 xff0e 先从 Serialize 说起 我们都知道 JAVA 中的 Serialize 机制 xff0c 译成串行化 序列化 xff0c 其作用是能将数据对象存入字节流当中 xff0c 在需要时重新生成对象 主要应用是利用外部存储设

  • 如何写好github上的README

    项目名称 xff08 超大字体或者是图片形式 xff09 这里再写一句骚气又精准的话描述你的项目吧 上手指南 写几句这样的话概括接下来的内容 xff1a 以下指南将帮助你在本地机器上安装和运行该项目 xff0c 进行开发和测试 关于如何将该

  • 如何阅读源码汇总

    译文 xff1a 从源码中学习 xff08 阅读源码 xff0c 初学者的有效成长方式 xff09 目录前言 为什么我们需要读源码 站在巨人的肩膀上 解决困难问题 扩展你的边界 应该读什么样的源码 如何读源码 预先准备 流程与技巧 结合上下

  • 如何调整修改电脑COM口号

    在有的时候 xff0c 我们使用USB转串口 xff0c 操作系统识别出的COM口号并没有按COM1 xff0c COM2 xff0c COM3 这样的顺序 xff0c 而如果恰巧我们使用的串口调试助手不能自动识别COM口 xff0c 只能

  • 调试程序时有些语句不执行 且不可设置成断点-调试代码与直接运行结果可能不一致原因剖析

    在keil下 xff0c 出现一些语句不能被编译 xff0c 或者不能打断点情况 不能设置断点的检查步骤 调试程序时有些语句不执行 且不可设置成断点 调试代码与直接运行结果可能不一致原因剖析

  • 1553B总线通信协议

    1553B总线基础知识 MIL STD 1553B详细介绍与学习记录 xff08 一 xff09

  • 软件设计模式概述

    Java设计模式 xff1a 23种设计模式全面解析 xff08 超级详细 xff09 设计模式 xff08 Design Pattern xff09 是前辈们对代码开发经验的总结 xff0c 是解决特定问题的一系列套路 它不是语法规定 x

  • GoF 的 23 种设计模式的分类和功能

    设计模式有两种分类方法 xff0c 即根据模式的目的来分和根据模式的作用的范围来分 1 根据目的来分 根据模式是用来完成什么工作来划分 xff0c 这种方式可分为创建型模式 结构型模式和行为型模式 3 种 创建型模式 xff1a 用于描述

  • UML统一建模语言是什么？

    UML xff08 Unified Modeling Language xff0c 统一建模语言 xff09 是用来设计软件蓝图的可视化建模语言 xff0c 是一种为面向对象系统的产品进行说明 可视化和编制文档的标准语言 xff0c 独立于

  • UML类图及类图之间的关系

    在 UML 2 0 的 13 种图中 xff0c 类图 xff08 Class Diagrams xff09 是使用频率最高的 UML 图之一 类图描述系统中的类 xff0c 以及各个类之间的关系的静态视图 xff0c 能够让我们在正确编写

  • UML统一建模语言是什么？

    UML xff08 Unified Modeling Language xff0c 统一建模语言 xff09 是用来设计软件蓝图的可视化建模语言 xff0c 是一种为面向对象系统的产品进行说明 可视化和编制文档的标准语言 xff0c 独立于

  • 探索Android中的Parcel机制（下）

    上一篇中我们透过源码看到了 Parcel 背后的机制 xff0c 本质上把它当成一个 Serialize 就可以了 xff0c 只是它是在内存中完成的序列化和反序列化 xff0c 利用的是连续的内存空间 xff0c 因此会更加高效 我们接下

  • 如何正确使用设计模式？

    设计模式不是为每个人准备的 xff0c 而是基于业务来选择设计模式 xff0c 需要时就能想到它 要明白一点 xff0c 技术永远为业务服务 xff0c 技术只是满足业务需要的一个工具 我们需要掌握每种设计模式的应用场景 特征 优缺点 xf

  • 开闭原则——面向对象设计原则，使用开闭原则解决实际问题

    在软件开发中 xff0c 为了提高软件系统的可维护性和可复用性 xff0c 增加软件的可扩展性和灵活性 xff0c 程序员要尽量根据 7 条原则来开发程序 xff0c 从而提高软件开发效率 节约软件开发成本和维护成本 我们将在下面的几节中依

  • 里氏替换原则——面向对象设计原则

    在上一节 开闭原则 中 xff0c 我们详细介绍了开闭原则 xff0c 本节我们来介绍里式替换原则 里氏替换原则的定义 里氏替换原则 xff08 Liskov Substitution Principle xff0c LSP xff09 由

  • 依赖倒置原则——面向对象设计原则

    前两节我们详细介绍了面向对象设计原则中的开闭原则和里氏替换原则 xff0c 在本节中我们来介绍依赖倒置原则 依赖倒置原则的定义 依赖倒置原则 xff08 Dependence Inversion Principle xff0c DIP xf

热门标签