GoF23-依赖倒置原则

本文主要是介绍GoF23-依赖倒置原则，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

依赖倒置原则

依赖倒置原则概念

依赖倒置原则(Dependence Inversion Principle)是指：1.高层模块不应该依赖低层模块，二者都应该依赖其抽象2.抽象不应该依赖细节，细节应该依赖抽象3.依赖倒置的中心思想是面向接口编程4.依赖倒置原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定得多。以抽象为基础搭建的架构比以细节为基础的架构要稳定得多。在Java中，抽象指的是接口或抽象类，细节就是具体的实现类5.使用接口或抽象类的目的是规定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成

应用场景

完成模拟Person接收消息的功能
（例如接收邮件、qq、微信消息）

代码实现(传统方法)

package com.tan.principle.dependence_inversion;public class DependenceInversion {public static void main(String[] args) {Person person = new Person();person.receive(new Email());}
}class Email {public String getInfo() {return "请查收邮件：Hello World";}
}/*
完成Person接收消息的功能
问题分析：
1.方法简单
2.receive方法的形参是一个Email类，那如果接收到的qq消息，微信消息等等，则不仅需要新增一个类，且Person类也要增加相应的接受方法解决思路：
引入一个抽象的接口IReceiver,表示接收者,这样Person类与接口IReceiver发生依赖
此时Email、WeChat等等属于接受的范围，它们各自实现IReceiver接口就可以，这样就使代码符合依赖倒置原则*/
class Person {public void receive(Email email){System.out.println(email.getInfo());}}

代码优化(依赖倒置原则)

package com.tan.principle.dependence_inversion.improve;/*
跟接口发生依赖依赖关系传递的三种方式：
1.接口传递
2.构造方法传递
3.setter方法传递*/
public class DependenceInversionImprove {public static void main(String[] args) {Person person = new Person();person.receive(new Email());person.receive(new WeChat());}
}//定义接口
interface IReceiver {public String getInfo();
}class Email implements IReceiver {public String getInfo() {return "请查收邮件：Hello World";}
}class WeChat implements IReceiver {public String getInfo() {return "请查收微信信息：Hello World";}
}class Person {public void receive(IReceiver receiver){System.out.println(receiver.getInfo());}}

依赖关系传递的三种方式

依赖关系传递的三种方式：
1.接口传递
2.构造方法传递
3.setter方法传递

package com.tan.principle.dependence_inversion.improve;/*
依赖关系传递的三种方式：
1.接口传递
2.构造方法传递
3.setter方法传递*/
public class DependencyPass {public static void main(String[] args) {
//        ChangHong changHong = new ChangHong();
//        OpenAndClose openAndClose = new OpenAndClose();
//        openAndClose.open(changHong);//        ChangHong changHong = new ChangHong();
//        OpenAndClose openAndClose = new OpenAndClose(changHong);
//        openAndClose.open();ChangHong changHong = new ChangHong();OpenAndClose openAndClose = new OpenAndClose();openAndClose.setTv(changHong);openAndClose.open();}
}class ChangHong implements ITV {@Overridepublic void play() {System.out.println("打开了长虹电视机");}
}/*
方式一：通过接口实现依赖传递*///interface IOpenAndClose {
//    public void open (ITV tv);//抽象方法，接受接口
//}
//
ITV接口
//interface ITV {
//public void play();
//}
//
实现接口
//class OpenAndClose implements IOpenAndClose {
//    public void open(ITV tv){
//        tv.play();
//    }
//}/*
方式二：通过构造方法实现依赖传递*/
//interface IOpenAndClose {
//    //抽象方法
//    public void open();
//}
//
//interface ITV {
//    public void play();
//}
//
//class OpenAndClose implements  IOpenAndClose{
//    //成员
//    public ITV tv;
//
//    //构造器
//    public OpenAndClose(ITV tv){
//        this.tv = tv;
//    }
//
//
//    public void open() {
//        this.tv.play();
//    }
//}/*
方法三：通过setter方法实现依赖传递*/
interface IOpenAndClose {//抽象方法public void open();public void setTv(ITV tv);
}//ITV接口
interface ITV {public void play();
}class OpenAndClose implements IOpenAndClose {private ITV tv;public void setTv(ITV tv) {this.tv = tv;}public void open() {this.tv.play();}
}

依赖倒置原则的注意事项

依赖倒置原则的注意事项：
1.低层模块尽量都要有抽象类或接口，或者两者都有，程序稳定性更好2.变量的声明类型尽量是抽象类或接口，这样我们的变量引用和实际对象间，就存在一个缓冲层，利于程序扩展和优化3.继承时遵循里氏替换原则

这篇关于GoF23-依赖倒置原则的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---