设计模式笔记（三）设计六大原则之三--依赖倒置原则

Dependence Inversion Principle, DIP

定义

1.高层模块不应该依赖底层模块，两者都应该依赖其抽象

2.抽象不应该依赖细节

3.细节应该依赖抽象

即：

1.模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或抽象类产生的；

2.接口或抽象类不依赖于实现类

3.实现类依赖接口或抽象类

优点

1.减少类间的耦合性，提高系统稳定性

举个栗子：

/*
* 司机
*/
public class Driver {
//司机的主要职责就是驾驶汽车
public void drive(Benz benz) {
benz.run();
}
}

/*
* 奔驰汽车
*/
public class Benz {
//汽车肯定会跑
public void run() {
System.out.println("奔驰汽车开始运行...");
}
}

/*
* 司机开车场景模拟
*/
public class Client {
public static void main(String[] args) {
Driver zhangSan = new Driver();
Benz benz = new Benz();
//张三开奔驰车
zhangSan.drive(benz);
}
}

现在司机不仅要开奔驰车，还要开宝马车：

/*
* 宝马车
*/
public class BMW {
//宝马车开动
public void run() {
System.out.println("宝马汽车开始运行...");
}
}

但是我们现在发现，司机并不能开宝马车。这显然不合理，原因就是司机类和奔驰类是紧耦合的关系，这样一旦有新的车，比如宝马车来了，司机类就需要改动它的类代码，维护性大大降低，不稳定。

2.降低并行开发引起的风险，提高代码的可读性和可维护性。

现在开发的时候人员都是协作开发，可能每个人负责一个模块，也可能每个人负责一个类的编写或方法的编写。假如现在司机类由A来编写，奔驰车类由B来编写，很显然，在B编写完之前，A是不能开发成功的，为什么呢？编译器就不通过了，只能B开发完奔驰车类再由A来开发司机类，这样显然不利于项目进度，所以要解决模块之间的依赖关系。

按照依赖倒置原则，我们所有的高层模块都应该依赖于接口或抽象类。

/*
* 司机接口
*/
public interface IDriver {
//司机会驾驶汽车
public void drive(ICar car);
}

/*
* 司机
*/
public class Driver implements IDriver{
//司机的主要职责就是驾驶汽车
//  public void drive(Benz benz) {
//      benz.run();
//  }

@Override
public void drive(ICar car) {
car.run();
}
}

/*
* 汽车接口
*/
public interface ICar {
//汽车都能跑
public void run();
}

/*
* 奔驰汽车
*/
public class Benz implements ICar{
//汽车肯定会跑
public void run() {
System.out.println("奔驰汽车开始运行...");
}
}

/*
* 宝马车
*/
public class BMW implements ICar {
//宝马车开动
public void run() {
System.out.println("宝马汽车开始运行...");
}
}

/*
* 司机开车场景模拟
*/
public class Client {
public static void main(String[] args) {
Driver zhangSan = new Driver();
Benz benz = new Benz();
//张三开奔驰车
zhangSan.drive(benz);

//张三开宝马车
zhangSan.drive(new BMW());
}
}

这时我们要让司机开宝马车只需要实现汽车接口即可，司机类不需要改动任何代码，即接口或抽象类（IDriver）并不依赖于汽车时哪一种的（细节）。

依赖的三种写法

这里的原理是依赖是可以传递的，只要做到抽象依赖，那么多层的传递也是正确的。

构造函数注入

/*
* 司机接口
*/
public interface IDriver {
//司机会驾驶汽车
public void drive(ICar car);
}

public class Driver implements IDriver{
private ICar car;

//构造函数注入
public Driver(ICar _car) {
this.car = _car;
}

//司机的主要职责就是驾驶汽车
public void drive() {
this.car.run();
}
}

setter依赖注入

/*
* 司机接口
*/
public interface IDriver {
//车辆型号
public void setCar(ICar car);
//司机会驾驶汽车
public void drive(ICar car);
}

public class Driver implements IDriver{

private ICar car;

//构造函数注入
public void setCar(ICar _car) {
this.car = _car;
}

//司机的主要职责就是驾驶汽车
public void drive() {
this.car.run();
}
}

接口声明依赖对象

/*
* 司机接口
*/
public interface IDriver {
//车辆型号
public void setCar(ICar car);
//司机会驾驶汽车
public void drive(ICar car);
}