00_2面向对象设计原则-依赖倒置原则

依赖倒转原则：依赖接口编程，不要依赖实现编程。高层模块不应该依赖低层模块，它们都应该依赖抽象。抽象不应该依赖于细节，细节应该依赖于抽象。

通过依赖倒置，可以降低类与类之间的耦合性，提高系统的稳定性，提高代码的可读性和维护性，并降低修改程序带来的风险。

下面我们来看一下例子，还是以课程为例：

package org.test.design.principle.dip;

public class Tom {
    public void studyJavaCourse() {
        System.out.println("Tom 在学习java的课程");
    }

    public void studyPythonCourse() {
        System.out.println("Tom在学习Python的课程");
    }

    //测试代码
    public static void main(String[] args) {
        Tom tom = new Tom();
        tom.studyJavaCourse();
        tom.studyPythonCourse();
    }
}

Tom正在学习java课程和Python课程。随着学习兴趣的增长，他还想学习AI课程。这个时候，需要业务扩展，代码要从底层到高层一次修改代码，这里高层指的是调用层。在Tom类中增加studyAICourse()方法，在高层也要追加调用。这样一来，在系统发布以后，实际上是非常不稳定的，在修改代码的同时会带来意想不到的风险。因些我们需要优化代码：

创建ICourse接口：

package org.test.design.principle.dip;

public interface ICourse {
    void study();
}

然后写JavaSourse类

package org.test.design.principle.dip;

public class JavaCourse implements ICourse{

    @Override
    public void study() {
        System.out.println("tom的学习java课程");
    }
}

在实现PythonCourse类

package org.test.design.principle.dip;

public class PythonCourse implements ICourse{
    @Override
    public void study() {
        System.out.println("tom 在学习Python课程");
    }
}

在来看一下V2版本的Tom类

package org.test.design.principle.dip;

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

    //测试调用
    public static void main(String[] args) {
        TomV2 tom = new TomV2();
        tom.study(new JavaCourse());
        tom.study(new PythonCourse());
    }
}

这时候在来看一下代码，Tom的学习兴趣无论怎么增长，对于新的课程，只需要新建设一个类，通过传递的方式告诉Tom，而不需要修改底层代码。实际上，这是一种大家非常熟悉的方式，叫作依赖注入。注入的方式还有构造器注入方式和Setter注入方式。下面来看一下构造注入方式。

来看一下Tom类的V3版本：

package org.test.design.principle.dip;

public class TomV3 {
    private ICourse course;
    public TomV3(ICourse course){
        this.course=course;
    }

    public void study(){
        course.study();
    }
    //测试调用
    public static void main(String[] args) {
        //Tom学习java课程
        TomV3 tom=new TomV3(new JavaCourse());
        tom.study();

        //Tom学习Python课程
        TomV3 tom2=new TomV3(new PythonCourse());
        tom2.study();
    }
}

我们在来看一下代码，根据构造器注入方式，当调用时，每次都要创建实例。那么，如果Tom是全局单例，则只能选择Setter注入方式，继续修改代码，来看一下V4版本的Tom类：

package org.test.design.principle.dip;

public class TomV4 {
    private ICourse course;

    public ICourse getCourse() {
        return course;
    }

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

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

    //测试调用
    public static void main(String[] args) {
        //Tom实例化
        TomV4 tom=new TomV4();

        //Tom学习java课程
        tom.setCourse(new JavaCourse());
        tom.study();

        //Tom学习Python课程
        tom.setCourse(new PythonCourse());
        tom.study();
    }
}

本篇结束。