设计模式之依赖倒置原则

依赖倒置原则(Dependence Inversion Principle,DIP)是指设计代码结构时，高层模块不应该依赖低层模块，二者都应该依赖其抽象，抽象不应该依赖细节，细节应该依赖抽象。通过依赖倒置，可以减少类与类之间的耦合性，提高系统的稳定性，代码的可读性和可维护性，并且能够降低修改程序所造成的风险。
来看以下代码：
1.创建一个Jack类,
public class Jack{
    public void studyJavaCourse(){
        System.out.println("Jack学习Java");
    }
    public void studyPythonCourse(){
        System.out.println("Jack学习Python");
    }
}
调用一下：
public static void main(String [] args){
    Jack jack = new Jack();
    jack. studyJavaCourse();
    jack.studyPythonCourse();
}

2.如果Jack还想学习AI课程，那么因为业务扩展，要从低层到高层（调用层）依次修改代码。在Jack类中添加studyAICourse方法，在高层也要追加调用。如此一来，再修改代码后会导致一些其它风险。来看一下优化后的代码。
public interface ICourse{
    void study();
}
public class JavaCourse implements ICourse{
    @override        
    public void study(){
        System.out.println("Jack学习Java");
    }
}
public class PythonCourse implements ICourse{
    @override        
    public void study(){
        System.out.println("Jack学习Python");
    }
}

修改Jack类
public class Jack{
    public void study(ICourse course){
        course.study();
    }
}

再看调用代码：
public static void main(String [] args){
    Jack jack = new Jack();
    jack. study(new JavaCourse());
    jack.study(new PythonCourse());
}
通过这种方式就可以在不修改原先的类，来实现业务的扩展。

3.对于新的扩展功能只需要新建一个类，通过传递参数到Jack类中就可以实现。这种方法称之为依赖注入。注入的方式还有构造器和setter。
先看一下构造器注入：
public class Jack{
    private ICourse course;
    public Jack(ICourse course){
        this.course = course;
    }
    public void study(){
        course.study();
    }
}
public static void main(String [] args){
    Jack jack = new Jack(new JavaCourse());
    jack. study();
}
通过构造器注入，每次调用都需要创建实例如果Jack是全局单例，可以用setter方式注入。
public class Jack{
    private ICourse course;
    public void setter(ICourse course){
        this.course = course;
    }
    public void study(){
        course.study();
    }
}
public static void main(String [] args){
    Jack jack = new Jack();
    jack.setter(new JavaCourse());
    jack. study();
    jack.setter(new PythonCourse());
    jack. study();
}