设计模式6大原则之【依赖倒置原则】

依赖倒置原则（Dependence Inversion Principle,DIP）

定义

• 高层模块不应该依赖低层模块，两者都应该依赖其抽象
• 抽象不应该依赖细节，细节应该依赖抽象
• 针对接口进行编程而不是针对实现编程

那什么是抽象？什么又是细节呢？在Java语言中，抽象就是指接口或抽象类，两者都是不能直接被实例化的；细节就是实现类，实现接口或继承抽象类而产生的类就是细节，其特点就是可以直接被实例化，也就是可以加上一个关键字new产生一个对象。依赖倒置原则在Java语言中的表现就是:
模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或抽象类产生的；接口或抽象类不依赖于实现类；实现类依赖接口或抽象类。更加精简的定义就是“面向接口编程”——OOD（Object-Oriented Design，面向对象设计）的精髓之一。

优点

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

代码案例

有如下代码，学生类（Student）中定义了学习语文、英语的方法，测试类（Test）进行调用

Student类

public class Student {
    public void StudyChinese(){
        System.out.println("学生学习语文");
    }
    public void StudyEnglish(){
        System.out.println("学生学习英语");
    }
}

Test类

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.StudyChinese();
        student.StudyEnglish();
    }
}

我们运行程序，有如下输出:

学生学习语文
学生学习英语

新需求

此时我们希望学生可以学习数学、学习物理等课程怎么办呢

在Student类中新增方法 StudyMath

public void StudyMath(){
   System.out.println("学生学习数学");
}

这种做法会产生一个问题：低层模块Student类会经常变化，导致代码经常修改，这与我们的依赖倒置原则是相违背的

面向抽象

我们将学习课程抽象为一个接口（ICourse）和多个实现类,让学生类（Student）依赖学习的接口（ICourse）而不是具体的实现，修改后的代码如下：
ICourse:

public interface ICourse {
    void study();
}

ChineseCourse:

public class ChineseCourse implements ICourse{
    @Override
    public void study() {
        System.out.println("学生学习语文");
    }
}

EnglishCourse:

public class EnglishCourse implements ICourse {
    @Override
    public void study() {
        System.out.println("学生学习英语");
    }
}

Student:

public class Student {
    public void Study(ICourse course){
        course.study();
    }
}

ICourse:

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.Study(new ChineseCourse());
        student.Study(new EnglishCourse());
    }
}

此时我们运行程序，打印的结果和之前一致，此时我们想要加入数学课程，只需要新建一个数学类（MathCourse），然后再上端进行调用就可以

public class MathCourse implements ICourse {
    @Override
    public void study() {
        System.out.println("学生学习数学");
    }
}

调用: student.Study(new MathCourse());

这样就做到了在不修改原有类的基础上，新增了功能，当然上层类是肯定要做出修改的，这是不可避免的。

依赖倒置的三种写法

1.接口声明依赖对象（上述案例中的方式）

public class Student {
    public void Study(ICourse course){
        course.study();
    }
}

2.通过构造函数传递依赖对象

public class Student {
    private ICourse course;
    public Student(ICourse course) {
        this.course = course;
    }
    public void Study(){
        this.Study();
    }
}

3.通过Setter依赖注入

public class Student {
    private ICourse course;
    public void setCourse(ICourse course) {
        this.course = course;
    }
    public void Study(){
        course.study();
    }
}

最佳实践

• 每个类尽量都有接口或抽象类，或者抽象类和接口两者都具备（这是依赖倒置的基本要求，接口和抽象类都是属于抽象的，有了抽象才可能依赖倒置）
• 变量的表面类型尽量是接口或者是抽象类
• 任何类都不应该从具体类派生
• 尽量不要覆写基类的方法:如果基类是一个抽象类，而且这个方法已经实现了，子类尽量不要覆写。类间依赖的是抽象，覆写了抽象方法，对依赖的稳定性会产生一定的影响