小试依赖倒置原则

╰+哭是因爲堅強的太久メ 2023-09-28 13:02 118阅读 0赞

### 定义 ###

高层模块不应该依赖底层模块，二者依赖其抽象。

> 所谓高层模块和低层模块的划分，简单来说就是，在调用链上，调用者属于高层，被调用者属于低层。

抽象不应该依赖细节，细节应该依赖抽象。

### 方式 ###

在本例中的 `Math` 和 `English` 都是被调用者，`Steve` 是调用方。两者都依赖与抽象 `ICourse`

### 思考 ###

[依赖反转、依赖倒置、依赖注入区别与联系][Link 1]

### 代码 ###

/**
     * 课程接口
     *
     * @author mindartisan.blog.csdn.net
     * @date
     */
    public interface ICourse {
        
        void learn();
    }
    /**
     * 英语课
     *
     * @author mindartisan.blog.csdn.net
     * @date
     */
    public class English implements ICourse{
        
        @Override
        public void learn() {
        
            System.out.println("Steve 在学习 English");
        }
    }
    /**
     * 数学课
     *
     * @author mindartisan.blog.csdn.net
     * @date
     */
    public class Math implements ICourse {
        
        @Override
        public void learn() {
        
            System.out.println("Steve 在学习 Math");
        }
    }
    /**
     * Steve 用户
     *
     * @author mindartisan.blog.csdn.net
     * @date
     */
    public class Steve {
        
    
        // Version1：
        // public void learnEnglish() {
        
        //     System.out.println("Steve 在学习 Englist");
        // }
        // public void learnMath() {
        
        //     System.out.println("Steve 在学习 Math");
        // }
    
        // Version2：
        // public void learn(ICourse course) {
        
        //     course.learn();
        // }
    
        // Version3：
        // private ICourse course;
        //
        // public Steve(ICourse course) {
        
        //     this.course = course;
        // }
        // public void learn() {
        
        //     course.learn();
        // }
    
        // Version4：
        private ICourse course;
    
        public void setCourse(ICourse course) {
        
            this.course = course;
        }
    
        public void learn() {
        
            course.learn();
        }
    
    }
    /**
     * 依赖倒转原则
     *
     * @author mindartisan.blog.csdn.net
     * @date
     */
    public class DenpencyInversionTest {
        
        public static void main(String[] args) {
        
            // Version1：简单粗暴的方式
            // Steve steve = new Steve();
            // steve.learnEnglish();
            // steve.learnMath();
    
            // Version2：依赖于抽象，依赖注入的原型
            // Steve steve  = new Steve();
            // steve.learn(new English());
            // steve.learn(new Math());
    
            // Version3：
            // Steve mathSteve = new Steve(new Math());
            // mathSteve.learn();
            // Steve englishSteve = new Steve(new English());
            // englishSteve.learn();
    
            // Version4：
            Steve steve = new Steve();
            steve.setCourse(new Math());
            steve.learn();
            steve.setCourse(new English());
            steve.learn();
        }
    }

[Link 1]: https://mindartisan.blog.csdn.net/article/details/127148103