英文名称(Dependence Inversion Principle ,DIP)

定义：高层模块不应该依赖低层模块，应该依赖其抽象，抽象不应该依赖其细节，细节应该依赖其抽象。

这句话在java中的理解：

低层模块：具体细化的java类

高层模块：是由多个低层模块组成的。

抽象：指的是接口或者抽象类

依赖：存在类A的一个方法S,S传入的参数是另一个类B的实例，那么类A依赖于类B 我的理解---在项目开发中尽量将相同模块细化，类与类之间减少依赖关系，应该依赖其抽象类或者接口。

一个反面的例子：
----一个司机开宝马车。
按照常规的思维：定义一个司机类（Driver）有个void drive(BMW bmw)方法。该方法需要传入宝马车实例，

定义一个宝马车类(BMW) 有一个run方法。

public class DIPTest {
	public static void main(String[] args) {
		new Driver().drive(new BMW());
	}
}
class Driver{
	public void drive(BMW bmw){
		System.out.println("司机开车...");
		bmw.run();
	}
}
class BMW{
	public void run(){
		System.out.println("宝马车开动了....");
	}
}

更改需求，司机现在改开奔驰了，那么如果在这个类的基础上更改，我们需要给司机提供一个drive(Benz b)的方法。

同时再提供一个Benz类，提供一个run方法。那么就存在类之间的依赖性太大，不利于类的拓展。

----解决方案：

让细节类依赖其抽象，宝马车、奔驰车都具有run()方法，司机都具有drive(Car car)的方法。可以将共同的方法和类抽象成接口。

这样设计的好处，可以将司机和车分为两个模块进行开发，两者之间的依赖关系存在于接口，而具体实现类依赖于接口。这样在分工协作时，只需要各自定义好接口的操作方法就可以了。并且类的扩展性也大大提高。

package hpu.lzl.dip;

public class DIPTest2 {
    public static void main(String[] args) {
		IDriver d = new Driver2();
		ICar ic = new BenzCar();
		d.Driver(ic);
		System.out.println("----------------");
		d.Driver(new BMWCar());
	}
}
interface IDriver{
	public void Driver(ICar car); 
}
interface ICar{
	public void run();
}
class Driver2 implements IDriver{
	@Override
	public void Driver(ICar car) {
		System.out.println("司机开车.....");
		car.run();
	}
}
class BMWCar implements ICar{

	@Override
	public void run() {
		System.out.println("宝马车开动了....");
	}
	
}
class BenzCar implements ICar{

	@Override
	public void run() {
		System.out.println("奔驰车开动了....");
	}
	
}

依赖的三种写法

1、构造函数传递依赖

interface IDriver{
	public void drive(); 
}

class Driver2 implements IDriver{
	private ICar car;
	public Driver2(ICar car){
		this.car = car;
	}
	@Override
	public void drive() {
		System.out.println("司机发动车了...");
		car.run();
	}
}

2、setter方法传递依赖

interface IDriver{
	public void drive(); 
	public void setCar(ICar car);
}

class Driver2 implements IDriver{
	private ICar car;
	@Override
	public void drive() {
		System.out.println("司机开车.....");
		car.run();
	}

	@Override
	public void setCar(ICar car) {
		// TODO Auto-generated method stub
		this.car = car;
	}
}

3、接口传递依赖

interface IDriver{
	public void drive(ICar car); 
}

class Driver2 implements IDriver{
	@Override
	public void drive(ICar car) {
		System.out.println("司机发动车了...");
		car.run();
	}
}

我对依赖倒置的理解

依赖倒置首先要求类之间具有联系，将其联系抽象成接口或者抽象类，这样降低类之间的依赖。从而产生抽象类或接口之间的依赖，将具体事物时间的依赖转化成抽象接口的依赖。