很多初学编程的小伙伴在编程时会发现，自己写的类总是频繁的用到（依赖）其他类，一旦被依赖的类需要修改，那么其他的类也统统都要修改一遍，让人感觉烦不胜烦。若是小型的程序也紧紧是觉得烦而已，可一旦是大型的工程，这种强耦合的程序一旦有某一个细节放生改变，那是砸电脑的心都有。
各个具体类之间发生了直接的依赖关系，使得这些类紧紧地耦合在了一起，从而降低了程序的稳定性、可维护性和可读性。要解决这个问题，我们可以用一些方法来将这些程序解耦，降低其耦合性。这种方法就是我即将要讲到的依赖倒置原则（Dependence Inversion Principle ,DIP）。
定义
High level modules should not depend upon low level modules.Both should depend upon abstractions.Abstractions should not depend upon details.Details should depend upon abstractions.
高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。
也就是说，高层模块、低层模块、细节都应该依赖抽象。
- 低层模块：组成一个大逻辑的颗粒原子逻辑。
- 高层模块：颗粒原子逻辑组成的模块。
- 抽象：指接口或抽象类，两者都不能被实例化。
- 细节：实现类，实现接口或继承抽象类而产生的类就是细节，其特点就是可以直接被实例化。
java的精髓
依赖倒置原则在java中的三种含义：
- 模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或抽象类产生的；
- 接口或抽象类不依赖于实现类；
- 实现类依赖接口或抽象类。
这三种含义在java的精髓之一——面向接口编程中体现得淋漓尽致。
用与不用依赖倒置原则的对比
既然一开始就说到不用依赖倒置原则有多糟糕，那么下面我们就用一个简单的程序来证明一下。
不使用依赖倒置原则：
程序1
/**
* 大众汽车类
* @author 叶汉伟
*/
public class DaZhong {
public void run(){
System.out.println("开大众汽车");
}
}
/**
* 司机类
* @author 叶汉伟
*/
public class Driver {
public void drive(DaZhong daZhong){
daZhong.run();
}
}
public class Client {
public static void main(String[] args){
Driver Tom=new Driver();
DaZhong daZhong=new DaZhong();
Tom.drive(daZhong);
}
}
看上去没什么嘛，这不是好好的吗？好像也是哦。那么既然司机会开大众汽车，那应该会开宝马吧。我们让它开一下宝马试试。
先生产一辆宝马给他：
程序2
/**
* 宝马车类
* @author 叶汉伟
*/
public class BaoMa {
public void run(){
System.out.println("开宝马车");
}
}
当我们要让司机开宝马的时候，他确开不了，程序报错了。感情他考的是大众驾照，有宝马都开不了啊。
其实要让司机开宝马车也容易，把司机类开车方法的参数改一下就成了呗。的确可以。但又想想，现在知识多了个宝马车，如果我再多个奔驰、本田什么的，那不就是要经常改，大改特改？对于大型的项目来说，这是致命的。
使用依赖倒置原则
那么接下来，我们看一下使用依赖倒置原则有什么优势。
程序3
/**
* 车子接口
* @author 叶汉伟
*/
public interface ICar {
public void run();
}
/**
* 大众汽车类
* @author 叶汉伟
*/
public class DaZhong implements ICar{
public void run(){
System.out.println("开大众汽车");
}
}
/**
* 宝马车类
* @author 叶汉伟
*/
public class BaoMa implements ICar{
public void run(){
System.out.println("开宝马车");
}
}
/**
* 司机接口
* @author 叶汉伟
*/
public interface IDriver {
public void drive(ICar car);
}
/**
* 司机类
* @author 叶汉伟
*/
public class Driver implements IDriver{
public void drive(ICar car){
car.run();
}
}
public class Client {
public static void main(String[] args){
IDriver Tom=new Driver();
//Tom开大众汽车
ICar daZhong=new DaZhong();
Tom.drive(daZhong);
//Tom开宝马
ICar baoMa=new BaoMa();
Tom.drive(baoMa);
}
}
看，现在不仅可以开大众，而且可以开宝马了。要还有什么本田、奔驰汽车，一个drive方法都能开，而开其他的车只需要修改一下客户端就可以了。
上面的程序在实现类之间不发生依赖关系，他们的依赖关系是在接口处发生的，这样就可以大大的降低了类之间的耦合。其实这里不仅用到了依赖倒置原则，还用到了里氏替换原则，从类Client中可以看出来。
实现依赖的三种方法
对象的依赖关系可以通过三种方法来实现：
- 接口声明依赖对象
- 构造函数传递依赖对象
- setter方法传递依赖对象
接口声明依赖对象
在接口处就声明了依赖的对象。如程序3中的司机接口IDriver，其方法drive()的形参是ICar类型的。那么我们可以说IDrive与ICar放生了依赖关系，这个依赖对象在接口处已经声明了。接口声明依赖的方法也叫接口注入。
构造函数传递依赖对象
在类中通过构造函数声明依赖对象。具体实现如下：
程序4
/**
* 司机接口
* @author 叶汉伟
*/
public interface IDriver {
public void drive();
}
/**
* 司机类
* @author 叶汉伟
*/
public class Driver implements IDriver{
private ICar car;
//通过构造函数注入依赖对象
public Driver(ICar car){
this.car=car;
}
public void drive(){
this.car.run();
}
}
如果我们想要司机开宝马车，只需要将宝马车对象传入构造函数即可。这种方法又叫做构造函数注入。
setter方法传递依赖对象
这种方法通过在抽象中增加一个setter方法实现。具体实现如下：
程序5
/**
* 司机接口
* @author 叶汉伟
*/
public interface IDriver {
public void setCar(ICar car);
public void drive();
}
/**
* 司机类
* @author 叶汉伟
*/
public class Driver implements IDriver{
private ICar car;
//setter方法传递依赖对象
public void setCar(ICar car){
this.car=car;
}
public void drive(){
this.car.run();
}
}
若要司机开那种车，只需要将车子的对象通过Driver对象的setCar()方法传入即可。这种方法又叫setter依赖注入。
总结
通过依赖倒置原则，我们可以实现模块中的松耦合。具体来说总结为一下几点规则：
- 每个类尽量都有接口或抽象类，或者抽象类和接口两者都具备
- 变量的表面类型尽量是接口或者是抽象类
- 任何类都不应该从具体类派生
- 尽量不要覆写基类的方法
- 结合里氏替换原则使用
还没有形成面向接口编程的java学习者们，赶紧将这个规则用起来吧，用过一段之间，你会感觉水平飙升，在代码间游走更加柔韧有余。
