1.1依赖倒置原则

依赖倒置原则(Dependencolthvesion Principle, DIP) 是指设计代码结构时，高层模块不应该依赖低层模块,二者都应该依赖其抽象类。抽象类不应该依赖细节，细节应该依赖抽象。通过依赖倒置，可以减少类与类之间的耦合性，提高系统的稳定性，提高代码的可读性和可维护性，并且能够降低修改程序所造成的风险。

1.课程示例类

public class CourseExample {

    public void studyPythonCourse(){
        System.out.println("lzz学习了python教程");
    }

    public void studyGoCourse(){
        System.out.println("lzz学习了go教程");
    }

    public static void main(String [] args){
        CourseExample courseExample = new CourseExample();
        courseExample.studyGoCourse();
        courseExample.studyPythonCourse();
    }
}

如果想学习java了那么要在低层添加studyJavaCourse方法 main主函数里添加调用studyJavaCourse()
这样一旦发布 系统是非常不稳定的，所以我们来优化一下。

2.课程接口类

public interface ICourse {
    void study();
}

3.学习Python类

public class PythonCourse implements ICourse{
    @Override
    public void study() {
        System.out.println("lzz学习了python教程");
    }
}

4.学习Go语言类

public class GoCourse implements ICourse{
    @Override
    public void study() {
        System.out.println("lzz学习了go语言教程");
    }
}

5. 调用

public class CourseTest {

    public void study(ICourse course){
        course.study();
    }

    public static void main(String [] args){
        CourseTest courseTest =  new CourseTest();
        courseTest.study(new PythonCourse());
        courseTest.study(new GoCourse());

    }
}

通过以上示例我们发现,这样子我们无论添加什么课程都不需要去修改底层的代码了,只需要新增一个类，通过传参的方式告诉调用类就可以了.这里还可以使用构造器注入的方式实现.

6.构造器注入方式

public class CourseTest2 {

    private ICourse course;

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

    public void study(){
        course.study();
    }

    public static void main(String [] args){
        CourseTest2 courseTest =  new CourseTest2();
        courseTest.setCourse(new PythonCourse());
        courseTest.study();
        courseTest.setCourse(new GoCourse());
        courseTest.study();
    }
}