软件设计七大原则：（二）依赖倒置原则

一、依赖倒置原则简介

• 定义：高层模块不应该依赖底层模块，二者都应该依赖其抽象
• 抽象不应该依赖细节，细节应该依赖抽象
• 针对接口编程，不要针对实现编程

二、代码实现

public class Evan {
    
    

    private Course course;

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

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

public interface Course {
    
    

    void studyCourse();

}

public class JavaCourse implements Course{
    
    

    @Override
    public void studyCourse() {
    
    
        System.out.println("Evan 在学习Java课程");
    }
}

public class FeCourse implements  Course{
    
    

    @Override
    public void studyCourse() {
    
    
        System.out.println("Evan 在学习前端课程");
    }
}

public class PythonCourse implements Course {
    
    

    @Override
    public void studyCourse() {
    
    
        System.out.println("Evan在学习Python课程");
    }
}

public class DependencyInversionTest {
    
    
    //v4 通过 setter传入接口
    public static void main(String[] args) {
    
    
        Evan evan = new Evan();
        evan.setCourse(new JavaCourse());
        evan.studyCourse();

        evan.setCourse(new FeCourse());
        evan.studyCourse();

        evan.setCourse(new PythonCourse());
        evan.studyCourse();
    }
}

三、关于依赖倒置原则的理解

   /**
     * 关于"依赖倒置原则"的理解
     * 通过将Course接口 进行多种实现，然后让Evan的studyCourse中传入具体接口，
     * 从而进一步达到不动Evan这个类即可使用不同实现的目的。
     * 这样做实现了接口的高内聚，Course、Evan、DependencyInversionTest的低耦合。
     * 将功能的具体实现选择放到 高层次的模块(细节实现所在模块)中，
     * 这样做能够减少低层次的底层基类结构的修改，减少系统改动的同时方便扩展。
     * 假如说我们还需要学习Rust课程，那我们直接可以选择创建一个Course的实现类RustCourse，然后实现StudyCourse()方法，
     * 最后在主测试类中，evan.studyCourse(new RustCourse());即可完成业务处理。
     * 总之，面向接口编程，高层次的模块不应该依赖于低层次的模块。
     * 相对于细节的多变性，抽象的东西要稳定得多，底层模块去指定规则、规范、框架、大体流程。
     */