贯穿设计模式第三话--依赖倒转原则

🥳🥳🥳 茫茫人海千千万万，感谢这一刻你看到了我的文章，感谢观赏，大家好呀，我是最爱吃鱼罐头，大家可以叫鱼罐头呦~🥳🥳🥳

从今天开始，将开启一个专栏，【贯穿设计模式】，设计模式是对软件设计中普遍存在（反复出现）的各种问题，所提出的解决方案，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。为了能更好的设计出优雅的代码，为了能更好的提升自己的编程水准，为了能够更好的理解诸多技术的底层源码，设计模式就是基石，万丈高楼平地起,一砖一瓦皆根基。 ✨✨欢迎订阅本专栏✨✨

🥺 本人不才，如果文章知识点有缺漏、错误的地方 🧐，也欢迎各位人才们评论批评指正！和大家一起学习，一起进步! 👀

❤️ 愿自己还有你在未来的日子，保持学习，保持进步，保持热爱，奔赴山海！ ❤️

💬 最后，希望我的这篇文章能对你的有所帮助！ 🍊 点赞 👍 收藏 ⭐留言 📝 都是我最大的动力！

📃前言回顾

🔥【贯穿设计模式】第一话·设计模式初介绍和单一职责原则🔥

🔥【贯穿设计模式】第二话·设计模式的七大原则之开闭原则🔥

在第二篇文章中，我们了解设计模式的七大原则中第二个原则：开闭原则；

我们来回顾下，它的定义：扩展开放，对修改关闭，强调的是用抽象构建框架，用实现扩展细节，可以提高软件系统的可复用性及可维护性。

并且我们通过习题集价格不同的例子讲解并认识到当价格需求不同时代码所遇到的问题，值得注意的是：开闭原则是对扩展开放，对修改关闭，但这并不意味着不做任何修改，低层模块的变更，必然要有高层模块进行耦合，否则就是一个孤立无意义的代码片段。

🍒依赖倒转原则

今天我们要学习的是依赖倒转原则，高层模块不应该依赖低层模块，两者都应该依赖其抽象。

🍓概述

该原则是指高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象；依赖倒转的中心思想是面向接口编程；
依赖倒转原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在java中，抽象指的是接口或者抽象类，细节就是具体的实现类。使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成；
依赖倒转原则要求我们在程序代码中传递参数时或在关联关系中，尽量引用层次高的抽象层类;
简单理解就是针对接口编程，而不是针对实现编程，在程序中尽量使用抽象层进行编程；
比如有三个类A类、B类和C类（B类和C类的功能类似），现在A类需要B类的相关功能，所以A类直接依赖类B，但是后面不需要B类的功能，需要C类的功能了，此时又需要要将A类改为依赖类C，然后必须通过修改A类的代码来完成这一需求，此时我们应该将A类修改为依赖接口D，B类和C类各自实现接口D，A类通过接口D间接与B类或者C类发生联系，则会大大降低修改A类的几率。

🍚特点

依赖倒置原则是开闭原则的基础，指的是针对接口编程，依赖于抽象而不依赖于具体，通过依赖倒置可以使系统有以下优点：

可以降低类与类之间的耦合性；
提高系统的稳定性；
提高代码的可读性和可维护性；
并降低修改程序带来的风险。

🍜问题引出

在大学上学期间，每位同学都是需要上各种不同的必修课程，如语文、数学、英语等，但是还需要上一些额外的选修课程，如思想政治、心里健康、计算机编程等。那接下来就以学生学习课程为例来讲解下依赖倒转原则吧。

1. 建立一个Java课程类JavaCourse：

package com.ygt.principle.dip;

/**
 * 一个学习Java的课程
 */
public class JavaCourse {

    // 返回当前课程名，表示学习的是Java课程
    public String getCourse(){
        return "Java课程";
    }
}

2. 建议学生类Ygt学习课程：

package com.ygt.principle.dip;

/**
 * 建立一个学生类，叫做鱼罐头ygt
 */
public class Ygt {

    // 他有个特点就是特别爱学习（哈哈）,上学期间热衷上各种课程
    public void study(JavaCourse course){
        System.out.println("当前学习了" + course.getCourse());
    }
}

3. 建一个测试类DependenceInversion测试下学生上课：

package com.ygt.principle.dip;

// 测试依赖倒转
public class DependenceInversion {
    public static void main(String[] args) {

        // 这里测试下ygt学习上课。
        Ygt ygt = new Ygt();
        ygt.study(new JavaCourse());
    }
}

得到的结果：

当前学习了Java课程

ygt非常热爱学习，因为学习不是人生的全部，但学习都征服不了，那你还能做什么？所以除了学习，我别无选择哈哈。现在ygt除了学习Java课程后，还想学习另一门语言Sql课程，这个时候，业务代码要如何修改呢？按照现在的代码逻辑的话，业务要拓展，代码从课程类到调用类，都是需要修改代码的，如此一来，不仅违反了开闭原则，也违反了依赖倒转原则的了，并且在修改代码的同时，可能会带来意想不到的风险，先来看看粗鲁的修改代码吧！

4. 新增一个Sql课程SqlCourse：

package com.ygt.principle.dip;

/**
 * 增加一个Sql教程
 */
public class SqlCourse {

    // 返回当前课程名，表示学习的是SQL课程
    public String getCourse(){
        return "SQL课程";
    }
}

5. 修改ygt类中的学习方法：

package com.ygt.principle.dip;

/**
 * 建立一个学生类，叫做鱼罐头ygt
 */
public class Ygt {

    // 他有个特点就是特别爱学习（哈哈）,上学期间热衷上各种课程
//    public void study(JavaCourse course){
//        System.out.println("当前学习了" + course.getCourse());
//    }

    /**
     * 学习方法修改如下，将传参修改为SqlCourse
     */
    public void study(SqlCourse course){
        System.out.println("当前学习了" + course.getCourse());
    }
}

6. 修改测试类的调用：

package com.ygt.principle.dip;

// 测试依赖倒转
public class DependenceInversion {
    public static void main(String[] args) {

        // 这里测试下ygt学习上课。
        Ygt ygt = new Ygt();
//        ygt.study(new JavaCourse());
        // 修改为Sql课程
        ygt.study(new SqlCourse());

    }
}

得到的结果：

当前学习了SQL课程

以上可以看出，如果后续ygt想再学习一门新课程的话，就又得重新修改代码，从上到下的修改代码，非常的繁杂，而且出错风险极大，下面就一起来探讨下解决方法吧。

🫖解决方案

在依赖倒转的核心中，高层模块不应该依赖低层模块，两者都应该依赖其抽象，所以我们可以将课程类提取出来，进行抽象接口化，这样ygt就不是直接依赖于Java课程和Sql课程啦，而是依赖于课程接口，使他们之间的关系进行倒转。

1. 新增一个课程接口ICourse：

package com.ygt.principle.dip;

/**
 * 新增课程接口，每个课程都会一个方法，展示课程名字
 */
public interface ICourse {

    // 返回当前课程名
    String getCourse();
}

2. 修改Java课程和Sql课程，通过实现ICourse接口：

// Java课程
package com.ygt.principle.dip;

/**
 * 一个学习Java的课程
 *  实现ICourse接口
 */
public class JavaCourse implements ICourse{

    // 返回当前课程名，表示学习的是Java课程
    public String getCourse(){
        return "Java课程";
    }
}

// Sql课程
package com.ygt.principle.dip;

/**
 * 增加一个Sql教程
 *  实现ICourse接口
 */
public class SqlCourse implements ICourse{

    // 返回当前课程名，表示学习的是SQL课程
    public String getCourse(){
        return "SQL课程";
    }
}

3. 修改ygt中的学习方法：

package com.ygt.principle.dip;

/**
 * 建立一个学生类，叫做鱼罐头ygt
 */
public class Ygt {

    // 他有个特点就是特别爱学习（哈哈）,上学期间热衷上各种课程
//    public void study(JavaCourse course){
//        System.out.println("当前学习了" + course.getCourse());
//    }

//    /**
//     * 学习方法修改如下，将传参修改为SqlCourse
//     */
//    public void study(SqlCourse course){
//        System.out.println("当前学习了" + course.getCourse());
//    }

    /**
     * 学习方法修改如下，将传参修改为ICourse
     * 这样只要是实现ICourse接口的，都能学习啦！
     */
    public void study(ICourse course){
        System.out.println("当前学习了" + course.getCourse());
    }
}

4. 最后修改下测试类：

package com.ygt.principle.dip;

// 测试依赖倒转
public class DependenceInversion {
    public static void main(String[] args) {

        // 这里测试下ygt学习上课。
        Ygt ygt = new Ygt();
        ygt.study(new JavaCourse());
        // 修改为Sql课程
        ygt.study(new SqlCourse());

    }
}

得到的结果：

当前学习了Java课程
当前学习了SQL课程

可以看到，这样修改之后，就遵循了依赖倒转原则了，并且如果再新增一个课程的话，只需要新增一个类实现ICourse接口即可，就可以实现调用啦，无需修改ygt等代码了。

在实现依赖倒转原则时，需要针对抽象层编程，而将具体类的对象通过依赖注入的方式注入其他对象中。依赖注入是指当一个对象要与其他对象发生依赖关系时，通过抽象来注入所依赖的对象。而常用的注入方式有3种：接口注入、构造注入和Setter注入，接口注入在上面已经实现了，下面来看看如何实现其他两种注入吧：

构造注入：

通过构造函数来传入具体类的对象，

新建个类来测试构造注入：

package com.ygt.principle.dip;

/**
 * 测试构造注入
 */
public class Ygt2 {
    private ICourse course;

    public Ygt2(ICourse course) {
        this.course = course;
    }

    public void study(){
        System.out.println("当前学习了" + course.getCourse());
    }
}

调用方需要将JavaCourse对象作用ygt2对象的构造函数注入。

package com.ygt.principle.dip;

// 测试依赖倒转
public class DependenceInversion {
    public static void main(String[] args) {

//        // 这里测试下ygt学习上课。
//        Ygt ygt = new Ygt();
//        ygt.study(new JavaCourse());
//        // 修改为Sql课程
//        ygt.study(new SqlCourse());


        // 测试构造注入
        Ygt2 ygt2 = new Ygt2(new JavaCourse());
        ygt2.study();

    }
}

Setter注入：

通过Setter方法来传入具体类的对象，

新建个类来测试Setter注入：

package com.ygt.principle.dip;

/**
 * 测试Setter注入
 */
public class Ygt3 {

    private ICourse course;

    public void setCourse(ICourse course) {
        this.course = course;
    }

    public void study(){
        System.out.println("当前学习了" + course.getCourse());
    }
}

调用方需要将JavaCourse对象作用ygt2对象的构造函数注入。

package com.ygt.principle.dip;

// 测试依赖倒转
public class DependenceInversion {
    public static void main(String[] args) {

//        // 这里测试下ygt学习上课。
//        Ygt ygt = new Ygt();
//        ygt.study(new JavaCourse());
//        // 修改为Sql课程
//        ygt.study(new SqlCourse());


//        // 测试构造注入
//        Ygt2 ygt2 = new Ygt2(new JavaCourse());
//        ygt2.study();
        
        // 测试Setter注入
        Ygt3 ygt3 = new Ygt3();
        ygt3.setCourse(new JavaCourse());
        ygt3.study();

    }
}

🌸 完结

相信各位看官看到这里大致都对设计模式中的其中一个原则有了了解吧，依赖倒转原则实际上的定义就是高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象；它的核心思想是面向接口编程。

学好设计模式，让你感受一些机械化代码之外的程序设计魅力，也可以让你理解各个框架底层的实现原理。最后，祝大家跟自己能在程序员这条越走越远呀，祝大家人均架构师，我也在努力。接下来期待第四话：里氏替换原则。 💪💪💪

文章的最后来个小小的思维导图：

🧐 本人不才，如有什么缺漏、错误的地方，也欢迎各位人才们评论批评指正！🤞🤞🤞

🤩 当然如果这篇文章确定对你有点小小帮助的话，也请亲切可爱的人才们给个点赞、收藏下吧，非常感谢！🤗🤗🤗

🥂 虽然这篇文章完结了，但是我还在，永不完结。我会努力保持写文章。来日方长，何惧车遥马慢！✨✨✨

💟 感谢各位看到这里！愿你韶华不负，青春无悔！让我们一起加油吧！ 🌼🌼🌼

💖 学到这里，今天的世界打烊了，晚安！🌙🌙🌙