6大设计原则（3）：依赖倒置原则

依赖倒置原则：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);
	}
}