定义

依赖倒转原则，又称依赖倒置原则（Dependence Inversion Principle），又称DIP原则，即：上层模块不应该依赖底层模块，它们都应该依赖于抽象，抽象不应该依赖于细节，细节应该依赖于抽象。抽象对代码来说即接口或者抽象类 细节对代码来说即实现类。换句话说 依赖倒转原则的核心的理念 相对于细节来说，抽象要稳定得多。要求我们 面向接口编程，进行设计。

案例需求

工作人员接收微信老板发来的加班消息

方案一

定义工作人员Worker.java

/** * 工作人员 * @author:liyajie * @createTime:2022/1/30 20:08 * @version:1.0 */public class Worker {    /**     * 工作人员接收消息     * @author: liyajie     * @date: 2022/1/30 20:10     * @param weChat     * @return void     * @exception:     * @update:     * @updatePerson:     **/    public void getMessage(WeChat weChat){        weChat.sendMessage();    }}

定义微信消息类WeChat.java

/** * 微信消息类 * @author:liyajie * @createTime:2022/1/30 20:07 * @version:1.0 */public class WeChat {    /**     * 微信发送的消息     * @author: liyajie     * @date: 2022/1/30 20:10     * @param     * @return void     * @exception:     * @update:     * @updatePerson:     **/    public void sendMessage(){        System.out.println("微信上，老板找你加班了");    }}

定义测试类Test1.java

public class Test1 {    public static void main(String[] args) {        new Worker().getMessage(new WeChat());    }}

定义消息接口IMessage.java

/** * 消息接口 * @author:liyajie * @createTime:2022/1/30 20:15 * @version:1.0 */public interface IMessage {    void sendMessage();}

定义微信消息类WeChatNew.java

/** * 微信消息类 * @author:liyajie * @createTime:2022/1/30 20:07 * @version:1.0 */public class WeChatNew implements IMessage{    /**     * 微信发送的消息     * @author: liyajie     * @date: 2022/1/30 20:10     * @param     * @return void     * @exception:     * @update:     * @updatePerson:     **/    @Override    public void sendMessage(){        System.out.println("微信上，老板找你加班了");    }}

定义飞书类FeiShu.java

/** * 飞书消息类 * @author:liyajie * @createTime:2022/1/30 20:16 * @version:1.0 */public class FeiShu implements IMessage{    @Override    public void sendMessage() {        System.out.println("飞书上，老板喊你加班了");    }}

定义工作人员类WorkerNew.java

/** * 工作人员类 * @author:liyajie * @createTime:2022/1/30 20:18 * @version:1.0 */public class WorkerNew {    /**     * 工作人员接收消息     * @author: liyajie     * @date: 2022/1/30 20:10     * @param iMessage     * @return void     * @exception:     * @update:     * @updatePerson:     **/    public void getMessage(IMessage iMessage){        iMessage.sendMessage();    }}

定义测试类Test2.java

public class Test2 {    public static void main(String[] args) {        // 微信        new WorkerNew().getMessage(new WeChatNew());        // 飞书        new WorkerNew().getMessage(new FeiShu());    }}

方案一违反了依赖倒置原则，如果功能需求扩展，比如说需要扩展一种飞书发送消息，我们需要新增一个飞书类，并实现发送消息的功能，工作人员的类也需要修改接收消息的方法，客户端也需要进行相应的修改，改动大，风险大。

方案二遵守了依赖倒置原则，同样的需求扩展，抽象一个公共的消息接口，所有的微信，飞书等发送消息的类只要实现该接口，重写发送消息的方法，工作人员的接收消息方法以消息接口为入参，客户端只需要传入相应的消息实体类，扩展方便，耦合低。

总结

通过上面两个案例，我们可以得到以下结论:

低层模块尽量都要有抽象类或接口，或者两者都有，程序稳定性更好,变量的声明类型尽量是抽象类或者接口，这样我们的变量引用和实际对象间，就存在一个缓冲层， 利于程序扩展和优化预告

下篇我们需要分析的是里式替换原则，敬请期待！

如需获取源码，请关注后，私信发送"源码"给小编，非常感谢