✨作者：猫十二懿

❤️‍🔥账号：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 {
     @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总结

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

设计模式-依赖倒转原则

依赖倒转原则

1、依赖倒转原则

2、违反DIP原则

3、遵循DIP原则

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

4.1 接口传递

4.2 构造方法传递

4.3 setter方法传递

5、DIP总结