依赖倒置原则：DIP

定义：

高层模块不应该依赖低层模块，两者都应该依赖其抽象

抽象不应该依赖细节

细节应该依赖抽象

什么是高层模块？大概就是main方法那一块吧

什么是低层模块？各个类、接口

抽象就是指接口或抽象类，两者不能被实例化

细节就是实现类，可以实例化对象

依赖倒置原则在Java中的表现：面向接口编程

模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或抽象类产生的

接口或抽象类不依赖于实现类

实现类依赖接口或抽象类

依赖倒置原则的本质就是通过抽象使各个类或模块的实现彼此独立，不互相影响，降低模块之间的耦合性。

使用时所遵循的准则：

1.每个类尽量都有接口或者抽象类，这是依赖抽象的基本要求，有了抽象才能依赖倒置

2.变量的表面类型尽量是接口或是抽象类

表面类型是定义时赋予的类型等号左边

实际类型是对象的类型等号右边

3.任何类都不应该从具体类派生

4.尽量不要复写基类的方法

5.综合里氏替换原则使用

依赖倒置原则是6个实际原则中最难以实现的原则，它是实现开闭原则的重要途径，

依赖倒置原则没有实现就无法对扩展开放，对修改关闭。

只要记住是面向接口编程就基本上抓住了依赖倒置原则的核心。

直接套用书中的例子：

class Benz {
	public void run (){
		System.out.println("奔驰--->");
	}
}

class Driver{
	public void drive(Benz benz ){
		benz.run();
	}
}

public class Client {

	public static void main(String[] args) {
		Driver zhangsan = new Driver();
		Benz benz = new Benz();
		zhangsan.drive(benz);
	}
}

司机驾驶奔驰的场景。既然张三是司机，那么能开的车就不仅仅局限于奔驰这一种车，

假如让张三去开宝马，很难进行修改。奔驰类和司机类间的耦合性太强了，结果就导致了代码的可维护性大大降低了。

使用依赖倒置原则：

经过简单分析可知，需要一个司机，一辆车，至于是什么车还不确定。那就需要两个接口：IDriver、ICar

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

interface ICar {
	public void run();
}

然后再去实现这两个接口。

class BMW implements ICar {
	public void run() {
		System.out.println("宝马--->");
	}
}

class Benz implements ICar {
	public void run() {
		System.out.println("奔驰--->");
	}
}

class Driver implements IDriver {
	@Override
	public void drive(ICar car) {
		car.run();
	}
}

实现场景类：

public class Client {

	public static void main(String[] args) {
		IDriver zhangsan = new Driver();
		ICar benz = new Benz();
		ICar bmw = new BMW();
		zhangsan.drive(benz);
		zhangsan.drive(bmw);
	}
}