✨作者：猫十二懿

❤️‍🔥账号：CSDN 、掘金、个人博客、Github

🎉公众号：猫十二懿

依赖倒转原则

1、依赖倒转原则

Java中的依赖倒转原则（Dependency Inversion Principle，DIP）是指高层模块不应该依赖低层模块，而是应该通过抽象来互相依赖。

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

在进行程序设计时，需要尽量避免使用具体类作为参数、变量或返回值类型等，而应该使用抽象类型。
依赖倒转 (倒置) 的中心思想是面向接口编程。
依赖倒转原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在Java中，抽象指的是接口或抽象类，细节就是具体的实现类。
使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成。

2、违反DIP原则

违反依赖倒转原则的Java程序可能会造成以下问题：

导致代码耦合度过高。如果高层模块依赖于低层模块，那么这两个模块之间的耦合度将非常高，而且修改其中一个模块可能会影响到另一个模块。
限制了代码的可扩展性。如果高层模块依赖于低层模块，那么在添加新功能或修改现有功能时，可能需要修改多个模块的代码，这将使代码的可扩展性降低。
增加了代码的风险和复杂性。如果高层模块依赖于低层模块，那么这些模块之间的关系将变得非常复杂，同时也会增加代码出错的风险。

public class UserService {private MySQLDatabase database;public UserService() {database = new MySQLDatabase();}public User getUser(int id) {return database.getUser(id);}
}public class MySQLDatabase {public User getUser(int id) {// 从MySQL数据库获取用户信息}
}

在这个示例程序中，UserService依赖于MySQLDatabase。这意味着，如果需要将MySQLDatabase替换为另一个数据库，就必须修改UserService的代码，这将导致代码耦合度过高，并限制了程序的可扩展性。

正确的做法应该是将UserService改为依赖于一个抽象的IDatabase接口，而不是具体的MySQLDatabase类。

3、遵循DIP原则

public interface IDatabase {User getUser(int id);
}public class MySQLDatabase implements IDatabase {public User getUser(int id) {// 从MySQL数据库获取用户信息}
}public class UserService {private IDatabase database;public UserService(IDatabase database) {this.database = database;}public User getUser(int id) {return database.getUser(id);}
}

在这个修改后的程序中，UserService不再依赖于具体的MySQLDatabase类，而是依赖于IDatabase接口，因此这个程序遵循了依赖倒转原则。

同时，我们还将MySQLDatabase类实现了IDatabase接口，这样当我们需要将MySQLDatabase替换为另一个数据库时，只需要提供一个新的实现了IDatabase接口的类即可，并不需要修改UserService的代码。这样就提高了代码的可扩展性。

4、依赖关系传递的三种方式

4.1 接口传递

/*** 方式1: 通过接口传递实现依赖*/interface IOpenAndClose1 {public void open(ITV1 tv); //抽象方法,接收接口}interface ITV1 { //ITV接口public void play();}class OpenAndClose1 implements IOpenAndClose1 {@Overridepublic void open(ITV1 tv){tv.play();}
}class ChangHong1 implements ITV1 {@Overridepublic void play() {System.out.println("打开电视机");}}public class DependencyPass1 {public static void main(String[] args) {ChangHong1 changHong = new ChangHong1();OpenAndClose1 openAndClose = new OpenAndClose1();openAndClose.open(changHong);}
}

4.2 构造方法传递

/*** 方式2: 通过构造方法依赖传递*/interface IOpenAndClose2 {public void open(); //抽象方法}interface ITV2 { //ITV接口public void play();}class OpenAndClose2 implements IOpenAndClose2 {public ITV2 tv; //成员public OpenAndClose2(ITV2 tv){ //构造器this.tv = tv;}public void open(){this.tv.play();}}class ChangHong2 implements ITV2 {public void play() {System.out.println("长虹电视机，打开");}
}public class DependencyPass2 {public static void main(String[] args) {ChangHong2 changHong = new ChangHong2();//通过构造器进行依赖传递OpenAndClose2 openAndClose = new OpenAndClose2(changHong);openAndClose.open();}
}

4.3 setter方法传递

/*** 方式3: 通过setter方法传递*/
interface IOpenAndClose3 {public void open(); // 抽象方法public void setTv(ITV3 tv);
}interface ITV3 { // ITV接口public void play();
}class OpenAndClose3 implements IOpenAndClose3 {private ITV3 tv;public void setTv(ITV3 tv) {this.tv = tv;}public void open() {this.tv.play();}
}class ChangHong3 implements ITV3 {public void play() {System.out.println("长虹电视机，打开");}
}public class DependencyPass3 {public static void main(String[] args) {ChangHong3 changHong = new ChangHong3();//通过setter方法进行依赖传递OpenAndClose3 openAndClose = new OpenAndClose3();openAndClose.setTv(changHong);openAndClose.open();}
}