依赖倒置原则

Dependence Inversion Principle

• 高层模块不应该依赖低层模块，二者都应该依赖其抽象

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

• 依赖倒转(倒置)的中心思想是面向接口编程

• 使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的 任务交给他们的实现类去完成

• 依赖关系传递的三种方式：

  • 接口传递

package com.xin.principle;
    
    //实现依赖
    public class DependInterfaceTransfer {
        public static void main(String[] args) {
            //利用接口传递依赖关系
            ChangHong changHong = new ChangHong();
            Open open = new Open();
            open.open(changHong);
        }
    }
    
    //通过接口传递实现依赖
    interface  IOpen {
        void open(TV tv);
    }
    interface TV {
        void play();
    }
    
    class ChangHong implements TV {
    
        public void play() {
            System.out.println("长虹电视机，打开");
        }
    }
    
    class Open implements IOpen {
    	//接口传递
        public void open(TV tv) {
            tv.play();
        }
    }

• 构造器传递

package com.xin.principle;
        
        //实现依赖
        public class DependInterfaceTransfer {
            public static void main(String[] args) {
                //利用接口传递依赖关系
                ChangHong changHong = new ChangHong();
                Open open = new Open(changHong);
                open.open();
            }
        }
        
        //利用构造方法依赖传递
    interface  IOpen {
        void open();
    }
    interface TV {
        void play();
    }
    
    class ChangHong implements TV {
    
        public void play() {
            System.out.println("长虹电视机，打开");
        }
    }
    class Open implements IOpen {
    
        private TV tv;
        //构造器
        public Open(TV tv) {
            this.tv = tv;
        }
        public void open() {
            this.tv.play();
        }
    }    

• set方法传递

package com.xin.principle;

//依赖传递
public class DependTransfer {
    public static void main(String[] args) {
        //利用接口传递依赖关系
        ChangHong changHong = new ChangHong();
        Open open = new Open();
        open.setTv(changHong);
        open.open();
    }
}

//利用set方法依赖传递
interface  IOpen {
    void open();
}
interface TV {
    void play();
}

class ChangHong implements TV {

    public void play() {
        System.out.println("长虹电视机，打开");
    }
}
class Open implements IOpen {

    private TV tv;

    //使用set方法
    public void setTv(TV tv) {
        this.tv = tv;
    }

    public void open() {
        this.tv.play();
    }
}

依赖倒置注意事项：

? 低层模块尽量都要有抽象类或接口，或者两者都有，程序稳定性更好.

? 变量的声明类型尽量是抽象类或接口, 这样我们的变量引用和实际对象间，就存在 一个缓冲层，利于程序扩展和优化

? 继承时遵循里氏替换原则

依赖倒置原则

原文：https://www.cnblogs.com/allure-xiaoxin/p/14774618.html