这个是开闭原则的基础，具体内容:针对接口编程，依赖于抽象而不依赖于具体。
    设计代码结构的时候, 高层模块不应该依赖底层模块,二者应该依赖它的抽象, 抽象不应该依赖细节, 细节依赖抽象.
    通过依赖倒置,减少类与类之间的耦合, 提高系统的稳定性, 可维护性. 降低修改程序造成的风险.

    例子
    还是以课程为例

    1. public class Tom {
    3.     public void studyJavaCourse() {
    4.         System.out.println("tom在学习java课程");
    5.     }
    7.     public void studyPythonCourse() {
    8.         System.out.println("tom在学习python课程");
    9.     }
    10. }

    来调用一下

    1. public static void main(String[] args) {
    2.         Tom tom = new Tom();
    3.         tom.studyJavaCourse();
    4.         tom.studyPythonCourse();
    5.     }

    tom热爱学习, 后续还会学习AI, 大数据.
    这时候, 需要从低层到高层依次修改, 在tom中增加studyAI(),高层也要追加调用, 这样一来我们的系统非常不稳定

    我们创建个接口

    1. public interface ICourse {
    2.     void study();
    3. }

    java课程接口

    1. public class JavaCourse implements ICourse {
    2.     @Override
    3.     public void study() {
    4.         System.out.println("正在学习java课程");
    5.     }
    6. }

    python课程接口

    1. public class PythonCourse implements ICourse {
    2.     @Override
    3.     public void study() {
    4.         System.out.println("正在学习python课程");
    5.     }
    6. }

    我们来调用下

    1. public class Tom {
    3.     public void study(ICourse course) {
    4.         course.study();
    5.     }
    7.     public static void main(String[] args) {
    8.         Tom tom = new Tom();
    9.         tom.study(new JavaCourse());
    10.         tom.study(new PythonCourse());
    11.     }
    12. }

    tom的兴趣无论再怎么多, 只要添加类, 通过传参数的方式告诉调用那边就行
    传参数还有构造器注入, setter方法

    image.png