1 基本介绍
依赖倒转原则(Dependency Inversion Principle,DIP)是面向对象设计中的一个重要原则,旨在降低类间的依赖关系,提高系统的灵活性和可维护性。
高层模块不应该依赖低层模块,二者都应该依赖其抽象
抽象不应该依赖细节,细节应该依赖抽象:这里的“高层模块”指的是调用者或者用户,而“低层模块”指的是被调用者或服务提供者。通过引入抽象层(如接口或抽象类),高层模块与低层模块之间实现了解耦,提高了系统的可扩展性和可维护性。
依赖倒转(倒置)的中心思想是面向接口编程,尽量使用接口类型作为方法参数、返回类型和成员变量的类型,这样可以极大地提升代码的灵活性和可替换性。
依赖倒转原则是基于这样的设计理念:相对于细节的多变性,抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在 java 中,抽象指的是接口或抽象类,细节就是具体的实现类
使用接口或抽象类的目的是制定好规范,而不涉及任何具体的操作,把展现细节的任务交给他们的实现类去完成
2 应用实例
Person 接收消息的功能
2.1 方案1
简单,比较容易想到。
但如果我们获取的对象是 微信,短信等等,则新增类,同时 Persons 也要增加相应的接收方法
public class DependecyInversion {
public static void main(String[] args) {
Person person = new Person();
person.receive(new Email());
}
}
class Email {
public String getInfo() {
return "电子邮件信息: hello,world";
}
}
// 方式 1 分析
class Person {
public void receive(Email email) {
System.out.println(email.getInfo());
}
}
2.2 方案二(依赖倒转)
解决思路:引入一个抽象的接口 IReceiver, 表示接收者, 这样 Person 类与接口 IReceiver 发生依赖
因为 Email, WeiXin 等等属于接收的范围,他们各自实现 IReceiver 接口就 ok, 这样我们就符号依赖倒转原则。
public class DependecyInversion {
public static void main(String[] args) {
// 客户端无需改变
Person person = new Person();
person.receive(new Email());
person.receive(new WeiXin());
}
}
// 定义接口
interface IReceiver {
public String getInfo();
}
class Email implements IReceiver {
public String getInfo() {
return "电子邮件信息: hello,world";
}
}
// 增加微信
class WeiXin implements IReceiver {
public String getInfo() {
return "微信信息: hello,ok";
}
}
// 方式 2
class Person {
// 这里我们是对接口的依赖
public void receive(IReceiver receiver ) {
System.out.println(receiver.getInfo());
}
}
3 依赖关系传递的三种方式
3.1 接口传递
// 方式 1: 通过接口传递实现依赖
// 开关的接口
interface IOpenAndClose {
public void open(ITV tv); // 抽象方法,接收接口
}
interface ITV { // ITV 接口
public void play();
}
class ChangHong implements ITV {
@Override
public void play() {
System.out.println("长虹电视机,打开");
}
}
// 实现接口
class OpenAndClose implements IOpenAndClose{
public void open(ITV tv){
tv.play();
}
}
3.2 构造方法传递
// 方式 2: 通过构造方法依赖传递
interface IOpenAndClose {
public void open(); // 抽象方法
}
interface ITV { // ITV 接口
public void play();
}
class OpenAndClose implements IOpenAndClose{
public ITV tv; // 成员
public OpenAndClose(ITV tv){ // 构造器
this.tv = tv;
}
public void open(){
this.tv.play();
}
}
3.3 setter 方式传递
// 方式 3 , 通过 setter 方法传递
interface IOpenAndClose {
public void open(); // 抽象方法
public void setTv(ITV tv);
}
interface ITV { // 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();
}
}
class ChangHong implements ITV {
@Override
public void play() {
System.out.println("长虹电视机,打开");
}
}
3.4 应用案例代码
public class DependencyPass {
public static void main(String[] args) {
ChangHong changHong = new ChangHong();
// 通过接口进行依赖传递
OpenAndClose openAndClose = new OpenAndClose();
openAndClose.open(changHong);
// 通过构造器进行依赖传递
OpenAndClose openAndClose = new OpenAndClose(changHong);
openAndClose.open();
// 通过 setter 方法进行依赖传递
OpenAndClose openAndClose = new OpenAndClose();
openAndClose.setTv(changHong);
openAndClose.open();
}
}
4 注意事项和细节
低层模块尽量都要有抽象类或接口,或者两者都有,程序稳定性更好.
变量的声明类型尽量是抽象类或接口, 这样我们的变量引用和实际对象间,就存在一个缓冲层,利于程序扩展和优化
继承时遵循里氏替换原则
5 总结
依赖倒转原则是指高层模块不应该依赖低层模块,二者都应该依赖于抽象;抽象不应该依赖细节,细节应该依赖于抽象。
这一原则的核心思想是面向接口编程,而不是面向实现编程。具体来说,依赖倒转原则鼓励开发者在设计软件时,尽量让模块依赖于抽象类或接口,而不是具体的实现类。这样做可以降低模块间的耦合度,提高系统的灵活性和可扩展性。