6大设计原则(三)—依赖倒置原则
最后更新于：2022-04-01 16:25:44
## 英文名称(Dependence Inversion Principle ,DIP)
**定义**：高层模块不应该依赖低层模块，应该依赖其抽象，抽象不应该依赖其细节，细节应该依赖其抽象。
**这句话在java中的理解**：
低层模块：具体细化的java类
高层模块：是由多个低层模块组成的。
抽象：指的是接口或者抽象类
依赖：存在类A的一个方法S,S传入的参数是另一个类B的实例，那么类A依赖于类B 我的理解---在项目开发中尽量将相同模块细化，类与类之间减少依赖关系，应该依赖其抽象类或者接口。
一个反面的例子：
----一个司机开宝马车。
按照常规的思维：定义一个司机类（Driver）有个void drive(BMW bmw)方法。该方法需要传入宝马车实例，
定义一个宝马车类(BMW) 有一个run方法。
~~~
public class DIPTest {
public static void main(String[] args) {
new Driver().drive(new BMW());
}
}
class Driver{
public void drive(BMW bmw){
System.out.println("司机开车...");
bmw.run();
}
}
class BMW{
public void run(){
System.out.println("宝马车开动了....");
}
}
~~~
**更改需求**，司机现在改开奔驰了，那么如果在这个类的基础上更改，我们需要给司机提供一个drive(Benz b)的方法。
同时再提供一个Benz类，提供一个run方法。那么就存在类之间的依赖性太大，不利于类的拓展。
**----解决方案**：
让细节类依赖其抽象，宝马车、奔驰车都具有run()方法，司机都具有drive(Car car)的方法。可以将共同的方法和类抽象成接口。
这样设计的好处，可以将司机和车分为两个模块进行开发，两者之间的依赖关系存在于接口，而具体实现类依赖于接口。这样在分工协作时，只需要各自定义好接口的操作方法就可以了。并且类的扩展性也大大提高。
~~~
package hpu.lzl.dip;
public class DIPTest2 {
public static void main(String[] args) {
IDriver d = new Driver2();
ICar ic = new BenzCar();
d.Driver(ic);
System.out.println("----------------");
d.Driver(new BMWCar());
}
}
interface IDriver{
public void Driver(ICar car);
}
interface ICar{
public void run();
}
class Driver2 implements IDriver{
@Override
public void Driver(ICar car) {
System.out.println("司机开车.....");
car.run();
}
}
class BMWCar implements ICar{
@Override
public void run() {
System.out.println("宝马车开动了....");
}
}
class BenzCar implements ICar{
@Override
public void run() {
System.out.println("奔驰车开动了....");
}
}
~~~
依赖的三种写法
## 1、构造函数传递依赖
~~~
interface IDriver{
public void drive();
}
class Driver2 implements IDriver{
private ICar car;
public Driver2(ICar car){
this.car = car;
}
@Override
public void drive() {
System.out.println("司机发动车了...");
car.run();
}
}
~~~
## 2、setter方法传递依赖
~~~
interface IDriver{
public void drive();
public void setCar(ICar car);
}
class Driver2 implements IDriver{
private ICar car;
@Override
public void drive() {
System.out.println("司机开车.....");
car.run();
}
@Override
public void setCar(ICar car) {
// TODO Auto-generated method stub
this.car = car;
}
}
~~~
## 3、接口传递依赖
~~~
interface IDriver{
public void drive(ICar car);
}
class Driver2 implements IDriver{
@Override
public void drive(ICar car) {
System.out.println("司机发动车了...");
car.run();
}
}
~~~
**我对依赖倒置的理解**
依赖倒置首先要求类之间具有联系，将其联系抽象成接口或者抽象类，这样降低类之间的依赖。从而产生抽象类或接口之间的依赖，将具体事物时间的依赖转化成抽象接口的依赖。