本文参考"设计模式之禅-秦小波"完成

接口制定标准，实例负责实现。

定义：

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

2.抽象不应该依赖细节，细节应该依赖抽象

更加精简的定义就是 "面向接口编程" ，类之间的依赖关系，通过接口(抽象类)进行定义（倒置的对象），而不是通过具体的实现类。

举例来说明，依赖倒置原则的定义。

以车司机和车为例，司机可以开宝马车，可以开奔驰车，也可以开出租车等等其他车。我们定义一个司机接口，一个车接口。同时定义他们之间的组合关系。司机接口调用车接口。其类图如下

司机接口和车接口的实现

public interface IDriver { void drive(ICar car);}public interface ICar { 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 Driver implements IDriver{ public void drive(ICar car) { car.run(); }}

在客户端(高层模块)调用

public class Client { public static void main(String[] args) { IDriver driver = new Driver(); // 我想开奔驰车，开..... driver.drive(new Benz());  // 我想开宝马车，开.... driver.drive(new BMW());  }}//运行结果奔驰车开始跑了啊啊。。。宝马汽车开始跑了啊啊...

我们在生活中，一个司机想开什么车，是直接开的，想开宝马，直接宝马开，想开奔驰，坐上奔驰就开走。

生活中的场景都是具体的实例。我们这个例子是司机和车抽象出了两接口，通过接口定义之间的依赖关系。具体情况再根据不同的车，司机去实现。这就是依赖倒置原则，将具体的依赖关系，"倒置"到抽象、基础类、接口中去定义实现，而不是具体的实例中，这是倒置这个词的来源。

客户端(高层模块)的实现，是通过调用接口实现的，不调用具体的实现类。

在java中抽象就是指抽象类，接口。细节是指实现类。

依赖导致原则在java中的表现：

模块间的依赖是通过抽象实现的，不是通过具体的实现类实现。 接口或者抽象类不依赖于实现类。 实现类依赖接口或者抽象类。

理解了依赖导致原则的定义，我们再来看看依赖倒置原则的优点。

优点：

采用依赖倒置原则，可以减少类间的耦合性。提高系统稳定性,提高代码的可读性和可维护性降低并行开发引起的风险。

我们来看看根据实际生活情况来实现，不用抽象的样子

三毛有一辆奔驰车

// 定义一个司机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 sanmao = new Driver(); //开着奔驰去接女朋友.... sanmao.drive(new Benz()); }}//运行结果...奔驰车开始跑了啊啊。。。

三毛觉得钱太多了，想花花钱，要买一辆宝马车开。

咦，我们发现我们的司机类里面，只有实现开奔驰的方法。不能开宝马，咋办。

这似乎不太合理，司机只能驾驶奔驰车，不能驾驶宝马车。

程序设计有问题了，司机类和奔驰类之间是紧耦合关系，我们需要再新增一个驾驶宝马的方法，才能驾驶宝马。每增加一个车，司机就需要增加一个驾驶方法。系统的可维护性，稳定性降低。稳定性的定义是(固话的，健壮的才是稳定的)。

被依赖者(车)的变更，要让依赖着(司机)来承担修改，这种关系放谁谁也受不了。

对于车来说，相同的代码，我们要读两份类，可读性降低。所以在程序的世界里，还是用依赖倒置原则实现，比较符合现实情况。

我们再来说说

减少并行开发引起的风险。并行开发是一个大的项目当中，将模块分化，然后不同的人负责不同的模块的开发。一个模块的错误最好不要波及其他功能和模块。

还是上面的车和司机为例，项目组里面一个人负责车模块，一个人负责

司机模块，那么如果不用依赖倒置原则，每增加一个车，就要让司机类的开发者写一份依赖。想想挺气人，是人都想干仗了。

同时司机类严重依赖车类，汽车类不开发完毕，司机类的开发也不能完毕。这样就拖慢了项目的进度。

那么我们把类设计好，车抽象类和司机抽象类，定义好依赖关系，司机依赖车。然后两个模块的人就可以快快乐乐的去开发了。模块之间的修改不互相牵扯，皆大欢喜。

通过以上举例，我们证明了依赖倒置原则的优点

1.采用依赖倒置原则，可以减少类间的耦合性。2.提高系统稳定性,提高代码的可读性和可维护性3.降低并行开发引起的风险，项目开发互相干扰

最后回忆一下依赖倒置原则的定义:

1.高层模块(如客户端，用抽象来调用和定义依赖关系)不依赖于底层模块，两者都依赖于抽象模块。

2.抽象不应该依赖细节，细节应该依赖抽象