依赖倒置原则

高层模块不应该依赖低层模块，二者都应该依赖其抽象；
抽象不应该依赖细节，细节应该依赖抽象；
针对接口编程，不要针对实现编程；
相对于细节的多变性，抽象要稳定的多；
核心就是面向接口编程；

依赖倒置原则示例类图

依赖倒置原则.png

依赖倒置原则示例代码

接口

public interface ICourse {
    void studyCourse();
}

实现类

public class FECourse implements ICourse {    
    @Override
    public void studyCourse() {
        System.out.println("Geely在学习FE课程");
    }
}

public class JavaCourse implements ICourse {
    @Override
    public void studyCourse() {
        System.out.println("Geely在学习Java课程");
    }    
}

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

上层类

• 上层类依赖于接口，没有依赖于具体的类；
• 注入方式是setter注入，也可以是构造器注入；

public class Geely {

    private ICourse iCourse;

    public void setiCourse(ICourse iCourse) {
        this.iCourse = iCourse;
    }

    public void studyImoocCourse(){
        iCourse.studyCourse();
    }

}

客户端

• Geely和ICourse是耦合的，但和具体的实现类是解耦的；

public class Test {

    //v1
//    public static void main(String[] args) {
//        Geely geely = new Geely();
//        geely.studyJavaCourse();
//        geely.studyFECourse();
//    }

    //v2
//    public static void main(String[] args) {
//        Geely geely = new Geely();
//        geely.studyImoocCourse(new JavaCourse());
//        geely.studyImoocCourse(new FECourse());
//        geely.studyImoocCourse(new PythonCourse());
//    }

    //v3
//    public static void main(String[] args) {
//        Geely geely = new Geely(new JavaCourse());
//        geely.studyImoocCourse();
//    }

    public static void main(String[] args) {
        Geely geely = new Geely();
        geely.setiCourse(new JavaCourse());
        geely.studyImoocCourse();

        geely.setiCourse(new FECourse());
        geely.studyImoocCourse();
    }

}

输出：

Geely在学习Java课程
Geely在学习FE课程