六大原则（四）：依赖倒置原则

定义：
①高级模块不应该依赖于低级模块，两者都应该依赖于抽象。
②抽象不应该依赖于细节。
③细节应该依赖于抽象。

那么高级模块、低级模块，抽象，细节各指的是什么呢？
每一个逻辑的实现都是由原子逻辑组成，不可分割的原子逻辑就是低级模块。而低级模块组装就是高级模块。
在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属性与方法，并且声明与其他对象的依赖关系，抽象类负责公共构造部分的实现，实现类准确的实现业务逻辑，同时在适当的时候对父类进行细化。

上面讲完了依赖关系与原则，那么什么叫倒置呢？
要理解倒置，首先我们得知道什么叫“正置”。依赖正置就是类之间的依赖是实现类间的依赖，也就是面向实现编程。但是编写程序需要的是对现实世界的事物进行抽象，转化为我们熟知的抽象类或接口，这样我们就可以将模块间的依赖关系、实现类间的依赖关系都是通过接口或抽象类产生。这就是我们所说的“倒置”。