白话 Android 设计模式 之 依赖倒转原则

1、简介

高层次的模块不应该依赖于低层次的模块，他们都应该依赖于抽象，
抽象不应该依赖于具体实现，具体实现应该依赖于抽象。

这听起来真的是像绕口令。
我们举一个 汽车 的例子
比如我们工厂生产汽车，有宝马、大众，现在我们要给我们生产的汽车加上自动驾驶技能。
如果按照面向过程的设计思路我们可能是：

一种从上到下的逻辑分类，这种随着车的种类越来越多，功能越来越复杂，会使的代码比较冗余和凌乱。

以来倒转原则来设计这种表现，则是将将自动驾驶抽取出来，设计一个接口，让不同的汽车实例对象来调用接口，从而实现 不同汽车 自动驾驶的体现。
将实际操作封装在对象之中。

2、参考示例讲解

1）
我们有很多不同的车，有不同的自动驾驶。
为了以后代码管理方便，以及减少代码耦合 ，我们可定会想到把不同的车进行区分。
比如宝马 class BWM，大众class VOL，分别建立一个类。

2）
同时他们都要有自动驾驶的功能，但是每个车的自动驾驶功能还不一样。
所以我们定义一个抽象类abstract class abstractAutoDriver，里面定义一个抽象的方法，自动驾驶 autoDriver，因为是抽象方法，所以具体实现都是在 子类里面。

package myapplication.lum.com.bird;

public abstract class abstractAutoDriver {
    public abstract void autoDriver();
}

我们让宝马 大众车 继承抽象类，复写自动驾驶方法 autoDriver ，具体实现各自的自动驾驶。

package myapplication.lum.com.bird;

import android.util.Log;

public class BWM extends abstractAutoDriver {
        private  String  TAG ="TAG_";
    @Override
    public void autoDriver() {
        Log.i(TAG,"宝马自动驾驶");
    }
}

package myapplication.lum.com.bird;

import android.util.Log;

public class VOL extends abstractAutoDriver {
    private  String  TAG ="TAG_";
    @Override
    public void autoDriver() {
        Log.i(TAG,"大众 自动驾驶");
    }
}

4）
这个时候，已经实现不同的汽车实现不同的驾驶，但是我们要有一个可以用与上层调用的接口。可以以通过统一的方式，传入不同的对象来实现不同的自动驾驶。

于是我们在写一个用于上层调用的类，承接不同抽象和实体对象之间的转化。

package myapplication.lum.com.bird;

public class AutoDriver   {
    public abstractAutoDriver carAutoDriver;

    public  AutoDriver(abstractAutoDriver carAutoDriver) {  //创建这个对象时将 不同车的实体对象传递过来，因为抽象时所有车的父类，所以可以进行转换
        this.carAutoDriver = carAutoDriver;
    }

    public void  start(){
        carAutoDriver.autoDriver(); //具体就会以实体对象去执行
    }
}

这个时候，我们依照不同的车，进行开启驾驶

package myapplication.lum.com.bird;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);


        BWM bwm = new BWM();
        AutoDriver autoDriverBwm = new AutoDriver(bwm);
        autoDriverBwm.start();

        VOL vol = new VOL();
        AutoDriver autoDriverVol = new AutoDriver(vol);
        autoDriverVol.start();

    }
}

log 打印：

比如这个时候我们 如果添加 BYD 只需要 添加 一个BYD 的类，定义自己的自动驾驶的方法。

package myapplication.lum.com.bird;

import android.util.Log;

public class BYD extends abstractAutoDriver {
    private  String  TAG ="TAG_";
    @Override
    public void autoDriver() {
        Log.i(TAG,"比亚迪 自动驾驶");
    }
}

这样就可以降低不同对象，不同方法之间的粘合度，在进行性能修改的时候，减少已有的代码的修改。

这个时候我们可以看到 我们的车时实体对象，通过继承抽象方法，能够在调用传递实体对象时对实体对象进行转换，从而识别出不同的对象的具体操作。

我们并没有直接去用不同的车实体对象调用各自的 autodriver

类似于 实例对象 ------> 抽象 ----->实例对象的具体方法

高层次的模块不应该依赖于低层次的模块，他们都应该依赖于抽象，
抽象不应该依赖于具体实现，具体实现应该依赖于抽象。