依赖倒转原则
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 { @Override public void open(ITV1 tv){ tv.play(); } } class ChangHong1 implements ITV1 { @Override public 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(); } }
5、DIP总结
- 低层模块尽量都要有抽象类或接口，或者两者都有，程序稳定性更好。
- 变量的声明类型尽量是抽象类或接口，这样我们的变量引用和实际对象间，就存在一个缓冲层，利于程序扩展和优化。
- 继承时遵循里氏替换原则。
