【1.2】依赖倒置原则
说到依赖倒置原则，肯定很多人比较迷糊了，什么是依赖？为什么还要倒置？依赖倒置有啥有点？
下面我们从依赖倒置原则得定义，实现方式等角度具体来说下。
一、定义
依赖倒置得原始定义是：
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 abstracts.
翻译过来的意思，包括以下三点:
1、高级模块不应依赖底层模块，两者都应依赖其抽象。
2、抽象不应该依赖其细节。
3、细节应该依赖其抽象。
高级模块和低层模块是什么意思呢?
一般我们的逻辑的实现都是由不可再分的原子逻辑组成，那么这个不可再分的原子逻辑就是低层模块，而由原子逻辑再组装的模块就是高级模块。
抽象很好理解，比较我们JAVA都是面向对象编程。抽象一般是指接口或者抽象类，两者都不能直接被实例化。而细节，就是其实现类。
那么我们现在再来看看依赖倒置的意思，他在JAVA上表现出来的意思就是：
1、模块间的依赖，通过抽象发生，实现类之间不能直接发生依赖关系，实现类之间的依赖关系是通过接口或者抽象类实现的。
2、接口或者抽象类不应该依赖实现类。
3、实现类要依赖接口或者抽象类。
二、我们为什么要使用依赖倒置？
编程时，我们常常会想我们为什么需要使用依赖倒置？依赖倒置有啥好处？
讲好处之前我们不妨先说说不使用依赖倒置的坏处。
我们构建一个驾驶员开车的场景：
如上图，我们可以看到，驾驶员开始得需要驾驶员（driver）类，和汽车类（car）。
Driver：
//驾驶员
public class Driver {
void driver(CarBenz car){
car.run();
}
}Car：
//汽车类
public class CarBenz {
void run(){
System.out.println("开奔驰咯。。。");
}
}开车：
import org.springframework.context.annotation.Bean;
public class Test {
public static void main(String[] args){
Driver driver = new Driver();
CarBenz benz = new CarBenz();
driver.driver(benz);
}
}输出结果为：
开奔驰咯。。。
看了上面的代码，似乎我们不用依赖倒置也是可以开车，实现驾驶的功能。
但是，生活毕竟是生活，我总不能只开这一辆车吧？如果我想换车开，怎么办？是不是就得改写driver里的方法？如果我不定期增加呢？是不是driver会越扩越大？
而且，这还不是最头疼的，如此写法，driver高度依赖Car，我们正常研发的话，如果A程序员研发driver，B程序员研发Car。那么A程序员必须等到B程序员研发完毕才可以开始工作，而测试则更是要等到B和A都完成后才开始。一旦B有所改动，牵一发就会牵一发而动全身。这会是一个让人崩溃的事。
这就像流水线，必须等到上一个人完成后，下一个人才可以开始，这是万万不能忍受的。
那么有没有更好的办法呢？
答案是肯定有，接下来欢迎：依赖倒置原则正式入场
ICard(汽车类接口)://汽车类接口
public interface ICard {
void run();
}Benz:public class Benz implements ICard {
@Override
public void run() {
System.out.println("开奔驰咯。。。");
}
}BMW:public class BMW implements ICard {
@Override
public void run() {
System.out.println("宝马启动啦。。。");
}
}IDriver：//司机接口
public interface IDriver {
void driver(ICard card);
}DriverImpl：//IDriver实现类
public class DriverImpl implements IDriver {
@Override
public void driver(ICard card) {
card.run();
}
}上车吧，兄弟：
import org.springframework.context.annotation.Bean;
public class Test {
public static void main(String[] args){
IDriver driver = new DriverImpl();
ICard card = new Benz();
driver.driver(card);
}
}这么一看，无论我们后来再添加什么车，只需要重新实现该车的实现类就可以了，对其他没有任何影响。
三、依赖倒置的三种写法：
对象的依赖有三种传递方式：
1、构造函数传递依赖对象
IDriver：
//司机接口
public interface IDriver {
void driver();
}DriverImpl：
//IDriver实现类
public class DriverImpl implements IDriver {
private ICard card;
public DriverImpl(ICard card){
this.card = card;
}
@Override
public void driver() {
this.card.run();
}
}
上车试试：
import org.springframework.context.annotation.Bean;
public class Test {
public static void main(String[] args){
IDriver driver = new DriverImpl(new BMW());
driver.driver();
}
}2、setter传递依赖对象
IDriver：
//司机接口
public interface IDriver {
void setter(ICard card);
void driver();
}DriverImpl：//IDriver实现类
public class DriverImpl implements IDriver {
private ICard card;
@Override
public void setter(ICard card) {
this.card = card;
}
@Override
public void driver() {
this.card.run();
}
}
试试：
public class Test {
public static void main(String[] args){
IDriver driver = new DriverImpl();
driver.setter(new Benz());
driver.driver();
}
}3、接口声明依赖对象
第二点采用的就是接口声明依赖对象，该方法也叫接口注入，这里就不再举例子了。