• 概念:指设计代码结构时,高层模块不应该依赖低层模块,二者应该依赖其抽象
    • 强调:抽象不应该依赖细节,细节应该依赖抽象
    • 通过依赖倒置,可以减少类与类之间的耦合性,提高系统的稳定性,提高代码的可读性和可维护性,降低修改程序所造成的风险

    事例一:

    改造前:

    1. public class Tom{
    2. public void studyJavaCourse(){
    3. System.out.println("Tom 在学习java课程")
    4. }
    5. public void studyPythonCourse(){
    6. System.out.println("Tom 在学习python课程")
    7. }
    8. public void studyAICourse(){
    9. System.out.println("Tom 在学习AI课程")
    10. }
    11. }
    1. public static void main(String[] args){
    2. Tom tom = new Tom();
    3. tom.studyJavaCourse();
    4. tom.studyPythonCourse();
    5. tom.studyAICourse();
    6. }

    改造后:

    依赖倒置(Dependence Inversion Principle) - 图1

    1. public interface ICourse{
    2. void study();
    3. }
    1. public class JavaCourse implements ICourse{
    2. public void study(){
    3. System.out.println("学习java课程")
    4. }
    5. }
    1. public class PythonCourse implements ICourse{
    2. public void study(){
    3. System.out.println("python课程")
    4. }
    5. }
    1. public class AICourse implements ICourse{
    2. public void study(){
    3. System.out.println("AI课程")
    4. }
    5. }
    1. public class Tom{
    2. private ICourse course;
    3. public Tom(ICourse course){
    4. this.course = course;
    5. }
    6. public void study(){
    7. course.study();
    8. }
    9. }
    1. public static void main(String[] args){
    2. Tom tom = new Tom(new AICourse());
    3. tom.study();
    4. }