1、什么是依赖倒置原则
    模块间的依赖关系通过抽象实现，实现类之间不发生直接的依赖关系，其依赖关系通过接口或抽象类完成；
    接口和抽象类不应该依赖于实现类；
    实现类应该依赖于接口和抽象类；

    2、如果不考虑依赖倒置原则会出现什么问题呢

    1. public class Driver {
    2.   //司机的主要职责就是驾驶汽车
    3.    public void drive(Benz benz){
    4.       benz.run();
    5.   }
    6. }
    8. public class Benz {
    9.     //汽车肯定会跑
    10.     public void run(){
    11.     System.out.println("奔驰汽车开始运行...");
    12.  }
    13. }
    15. //高层模块
    16. public class Client {
    17.    public static void main(String[] args) {
    18.      Driver xiaoLi = new Driver();
    19.      Benz benz = new Benz();
    20.     //小李开奔驰车
    21.     xiaoLi.drive(benz);
    22. }
    23. }

    如果现在自己想换辆宝马开开该怎么办，只能新增一个宝马类，然后在Driver类中新增一个方法，这样的改动就太大了，需求是想换辆车，但是司机也得该，修改的地方太多，出错的风险也就大了

    1. //将司机模块抽象为一个接口
    2. public interface IDriver {
    3.      //是司机就应该会驾驶汽车
    4.      public void drive(ICar car);
    5. }
    7. public class Driver implements IDriver{
    8.     //司机的主要职责就是驾驶汽车
    9.     public void drive(ICar car){
    10.         car.run();
    11.     }
    12. }
    14. //将汽车模块抽象为一个接口：可以是奔驰汽车，也可以是宝马汽车
    15. public interface ICar {
    16.       //是汽车就应该能跑
    17.       public void run();
    18. }
    20. public class Benz implements ICar{
    21.     //汽车肯定会跑
    22.     public void run(){
    23.         System.out.println("奔驰汽车开始运行...");
    24.   }
    25. }
    27. public class BMW implements ICar{
    28.    //宝马车当然也可以开动了
    29.    public void run(){
    30.       System.out.println("宝马汽车开始运行...");
    31.    }
    32. }
    34. //高层模块
    35. public class Client {
    36.      public static void main(String[] args) {
    37.        IDriver xiaoLi = new Driver();
    38.        ICar benz = new Benz();
    39.       //小李开奔驰车
    40.       xiaoLi.drive(benz);
    41.    }
    42. }

    3、DIP的三种写法
    接口声明依赖对象：在接口的方法中声明依赖对象，就如同上边的例子；
    构造函数传递依赖对象：

    1. //将司机模块抽象为一个接口
    2. public interface IDriver {
    3.      public void drive();
    4. }
    6. public class Driver implements IDriver{
    7.     private ICar car;
    9.     //注入
    10.     public void Driver(ICar car){
    11.       this.car = car;
    12.     }
    14.     public void drive(ICar car){
    15.         this.car.run();
    16.     }
    17. }

    set方法传递依赖对象：

    1. public interface IDriver{
    2.   //注入依赖
    3.   public void setCar(ICar car);
    5.   public void drive();
    6. }
    8. public class Driver implements IDriver{
    9.   private ICar car;
    11.   public void setCar(ICar car){
    12.     this.car = car;
    13.   }
    15.   public void drive(){
    16.     this.car.run();
    17.   }
    18. }

    4、总结
    依赖倒置原则的核心就是面向抽象（接口和抽象类）编程；