软件设计七大原则之依赖倒置原则

曾经终败给现在 2024-04-18 15:40 86阅读 0赞

### **依赖倒置原则：** ###

**定义：**

*  高层模块不应该依赖低层模块，二者都应该依赖其抽象。
 *  抽象不应该依赖细节；细节应该依赖抽象。
 *  针对接口编程，不应该针对实现编程。

**优点：**

可以减少类之间的耦合性，提高系统的稳定性，提高代码的可读性和可维护性，可降低修改程序所造成的风险。

**在java中的表现：**

*  模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或抽象类产生的。
 *  接口或抽象类不依赖实现类
 *  实现类依赖接口或抽象类

### **举例说明：** ###

**需求：**

现在要学习编程方面的课程，有 java, python, c, c\# ... （后期可能还要学习新课程）；

如果以常规方式去实现，我们可以在一个类中加入所有课程，然后通过调用即可，但是这样有一个缺点，就是当有新的课程加入时，我们都要去修改该类，这样写的可读性并不高，对后期的维护也非常不友好，那么如何解决呢？

**分析：**

先看一下实现后的UML图。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg3NjU0OA_size_16_color_FFFFFF_t_70][]

通过UML图可以看出，所要学习课程关系是并列的，并且都实现了同一个接口（StudyCourse），而Study类和实现类是没有关系的，但是和StudyCourse是有关系的，这样的话就减少了类之间的耦合性，后期维护也就方便多了。

**代码实现：**

先创建一个接口：

public interface StudyCourse {
        void studyCourse();
    }

实现该接口：

public class StudyJavaCourse implements StudyCourse {
        public void studyCourse() {
            System.out.println("学习java课程");
        }
    }

public class StudyPythonCourse implements StudyCourse {
        public void studyCourse() {
            System.out.println("学习Python课程");
        }
    }

......

创建一个类，调用 StudyCourse 类里的方法 studyCourse()；

public class Study {
        //方式一
        /*public void studyProgrammeCourse(StudyCourse studyCourse){
            studyCourse.studyCourse();
        }*/
        //方式二
        /*private StudyCourse studyCourse;
        public Study(StudyCourse studyCourse) {
            this.studyCourse = studyCourse;
        }
        public void studyProgrammeCourse(){
            studyCourse.studyCourse();
        }*/
        //方式三
        private StudyCourse studyCourse;
    
        public void setStudyCourse(StudyCourse studyCourse) {
            this.studyCourse = studyCourse;
        }
    
        public void studyProgrammeCourse(){
            studyCourse.studyCourse();
        }
    }

调用：

public class Test {
        //方式一：通过接口方法方式注入接口实现
        /*public static void main(String[] args) {
            Study study = new Study();
            study.studyProgrammeCourse(new StudyJavaCourse());
            study.studyProgrammeCourse(new StudyPythonCourse());
        }*/
        //方式二：通过构造器的方式调用
        /*public static void main(String[] args) {
            Study studyJava = new Study(new StudyJavaCourse());
            studyJava.studyProgrammeCourse();
            Study studyPython = new Study(new StudyPythonCourse());
            studyPython.studyProgrammeCourse();
        }*/
        public static void main(String[] args) {
            Study study = new Study();
            study.setStudyCourse(new StudyJavaCourse());
            study.studyProgrammeCourse();
            study.setStudyCourse(new StudyPythonCourse());
            study.studyProgrammeCourse();
        }
    }

至此，一个简单的以依赖倒置原则的小案例完成，从代码中我们可以看出依赖的三种方式。

**依赖的三种方式：**

依赖是可以传递，A对象依赖B对象，B又依赖C，C又依赖D，……，依赖不止。只要做到抽象依赖，即使是多层的依赖传递也无所谓惧。

*  接口依赖声名：在接口的方法中声明依赖对象，在为什么我们要符合依赖倒置原则的例子中，我们采用了接口声明依赖的方式，该方法也叫做接口注入。
 *  构造函数传递依赖对象；
 *  Setter方法传递依赖对象：在类中通过Setter方法声明依赖关系，依照依赖注入的说法，这是Setter依赖注入：

**总结：**

依赖倒置原则的本质就是通过抽象(接口或抽象类)使各个类或模块的实现彼此独立，不互相影响，实现模块间的松耦合。我们在项目中使用这个原则要遵循下面的规则：

*  每个类尽量都有接口或者抽象类，或者抽象类和接口两都具备
 *  变量的表面类型尽量是接口或者抽象类
 *  任何类都不应该从具体类派生
 *  尽量不要覆写基类的方法  
    如果基类是一个抽象类，而这个方法已经实现了，子类尽量不要覆写。类间依赖的是抽象，覆写了抽象方法，对依赖的稳定性会有一定的影响。
 *  结合里氏替换原则使用

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg3NjU0OA_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/e4d85197eccd47669bdaa14e6e8fdbc7.png