参考书籍：设计模式之禅 --- 秦小波 著
定义：
①高级模块不应该依赖于低级模块，两者都应该依赖于抽象。
②抽象不应该依赖于细节。
③细节应该依赖于抽象。
那么高级模块、低级模块，抽象，细节各指的是什么呢？
每一个逻辑的实现都是由原子逻辑组成，不可分割的原子逻辑就是低级模块。而低级模块组装就是高级模块。
在Java中，抽象就是指接口或抽象类，两者并不能直接被实例化。
细节就是实现类，继承抽象类或实现接口的类就是细节。特点是可以被直接实例化。
那么依赖倒置原则定义在Java语言中可以表示为：
①模块间的依赖关系、实现类间的依赖关系都是通过接口或抽象类产生。
②接口与抽象类不依赖实现类。
③实现类依赖接口或抽象。
从上述定义我们可以看出，依赖倒置原则的核心思想就是：面向接口编程
代码重现：
司机类
public class Driver {
public void drive(Benz benz){
benz.run();
}
}
奔驰类
public class Benz {
public void run(){
System.out.println("开奔驰车上路");
}
}
测试类
public class Demo_01 {
public static void main(String[] args) {
Driver sanmao = new Driver();
sanmao.drive(new Benz());
}
}
--------------------output---------------------------
开奔驰车上路
通过以上代码完成了司机类开奔驰车的场景。
但是随着业务需求的变更，现在要求这个司机还能开宝马车，那么上面代码必须要重写（耦合性太强），才能满足业务需求，显然上面代码在设计上有错误。
那么我们依据依赖倒置原则重构以上代码：
司机接口类
public interface IDriver {
void drive(ICar iCar);
}
司机实现类
public class Driver implements IDriver{
@Override
public void drive(ICar iCar) {
iCar.run();
}
}
汽车接口类
public interface ICar {
void run();
}
汽车实现类
public class Benz implements ICar{
@Override
public void run() {
System.out.println("开奔驰上路");
}
}
public class BMW implements ICar {
@Override
public void run() {
System.out.println("开宝马上路");
}
}
测试类
public class Demo_01 {
public static void main(String[] args) {
IDriver sanmao = new Driver();
ICar benz = new Benz();
ICar BMW = new BMW();
sanmao.drive(benz);
sanmao.drive(BMW);
}
}
--------------------output---------------------------
开奔驰上路
开宝马上路
Demo_01类就是高级模块，他对所有低级模块的依赖都建立在抽象类或接口上
在IDriver接口中传入ICar接口，实现模块间的依赖关系是通过接口或抽象类产生。在Driver实现类中也传入了ICar接口，究竟使用Car的哪个子类还得在测试类中声明。
在测试类中，我们贯彻“②接口与抽象类不依赖实现类。”，所以在测试类Demo_01中，我们都是声明了各类的抽象。
注意：在Java中，只要定义变量就必然要有类型。一个变量可以有两种类型：表面类型与实际类型。表面类型是在定义时赋予的类型，实际类型是对象的类型，如sanmao的表现类型是IDriver，实际类型为Driver。
依赖的三种写法
依赖是可以传递的。A对象依赖B对象，B依赖C，C依赖D...，
只要做到抽象依赖，即使是多层的依赖传递也无所畏惧。
对象的依赖关系有以下三种方式传递，可以参考Spring的依赖注入
①构造函数传递依赖关系
public interface IDriver {
void drive();
}
public class Driver implements IDriver{
private ICar iCar;
public Driver(ICar _iCar){
this.iCar = _iCar;
}
public void drive() {
this.iCar.run();
}
}
②Setter方法传递依赖关系
public interface IDriver {
void drive();
void setCar(ICar _iCar);
}
public class Driver implements IDriver{
private ICar iCar;
@Override
public void drive() {
this.iCar.run();
}
@Override
public void setCar(ICar _iCar) {
this.iCar = _iCar;
}
}
③接口声明依赖关系
public interface IDriver {
void drive(ICar iCar);
}
public class Driver implements IDriver{
@Override
public void drive(ICar iCar) {
iCar.run();
}
}
依赖倒置原则的本质就是通过接口或抽象类使得各模块间相互独立，互不影响，实现松耦合。在使用这个原则时，我们需要注意以下几个原则：
①每个类都尽可能的都有接口或抽象类，或者抽象类和接口两者都具备。（依赖倒置原则的基本要求）
②变量的表面类型尽量是接口或者抽象类。（工具类不需要接口或者抽象类，使用类的Clone方法，必须使用实现类，这是JDK的规范）
③任何类都不应该从具体类派生。
④尽量不要覆写基类的方法。（若基类是一个抽象类，此方法已经实现，那么子类就不应该覆写）
⑤结合里氏替换原则使用
接口负责public属性与方法，并且声明与其他对象的依赖关系，抽象类负责公共构造部分的实现，实现类准确的实现业务逻辑，同时在适当的时候对父类进行细化。
上面讲完了依赖关系与原则，那么什么叫倒置呢？
要理解倒置，首先我们得知道什么叫“正置”。依赖正置就是类之间的依赖是实现类间的依赖，也就是面向实现编程。但是编写程序需要的是对现实世界的事物进行抽象，转化为我们熟知的抽象类或接口，这样我们就可以将模块间的依赖关系、实现类间的依赖关系都是通过接口或抽象类产生。这就是我们所说的“倒置”。
