依赖倒置原则的理解

一直不太理解这个原则，直到看到了这个例子:

class DriverTest {
    @Test
    fun main(){
        val driver = Driver()
        val benz = Benz()
        driver.driver(benz)
    }
}

class Driver{
    fun driver(car: Benz){
        car.run()
    }
}

class Benz{
    fun run(){
        println("奔驰开始运行")
    }
}

此时司机又要驾驶宝马了，怎么办?
错误示范:

class DriverTest {

    @Test
    fun main(){
        val driver = Driver()
        val benz = Benz()
        driver.driver(benz)

        val bmw = BMW()
        driver.driver(bmw)
    }
}

class Driver{
    fun driver(car: Benz){
        car.run()
    }
    fun driver(car: BMW){
        car.run()
    }
}

class Benz{
    fun run(){
        println("奔驰开始运行")
    }
}

class BMW{
    fun run(){
        println("宝马开始运行")
    }
}

需要修改原来核心的Driver类，新增方法，也不符合开闭原则(对拓展开放，对修改关闭)。
正确示范:

/**
 * Created by Alex on 12/11/20
 */
class DriverTest {

    @Test
    fun main(){
        val driver = Driver()
        driver.driver(BenZ())
        driver.driver(BMW())

    }
}

class Driver{
    fun driver(car: ICar){
        car.run()
    }
}

interface ICar{
    fun run()
}

class BenZ: ICar{
    override fun run() {
        println("奔驰开始运行了")
    }
}

class BMW: ICar{
    override fun run() {
        println("宝马开始运行了")
    }
}

此时如果说还想开法拉利?
新建一个类继承ICar,实现run方法，完事儿了，是不是面向接口编程，是不是依赖抽象，而不说依赖细节？而且还符合开闭原则！
所以什么是依赖倒置?先看几个概念

抽象与细节，在Java中，抽象就是指接口或者抽象类，两者都是不能直接被实例化的；细节就是实现类，实现接口或者继承抽象类而产生的就是细节，以关键字new产生对象。

高层和低层，通俗来讲高层模块就是调用端，低层模块就是具体实现类。上面的例子中driver就是高层，car就是低层。

其核心思想是：要面向接口编程，不要面向实现编程。拓展一下
图片加载框架，常规使用Glide直接load res到imageview，这是强依赖，而符合依赖倒置原则的做法是 抽象一层xxx.load res 到imageview,而xxx是一个抽象类，具体的实现可以是Glide,也可以是Fresco。这就是依赖倒置