设计模式六大原则（3）：依赖倒置原则

前两回说到设计模式六大模式的两大心法，那么几天我们在看看这个第三大心法：依赖导致原则。

什么是依赖倒置原则？

定义：高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。
心法要诀：这个原则描述的是一个现实当中的事实，即实现都是易变的，而只有抽象是稳定的，所以当依赖于抽象时，实现的变化并不会影响客户端的调用。

心法适用的场景以及招式：

问题由来：类A直接依赖类B，假如要将类A改为依赖类C，则必须通过修改类A的代码来达成。这种场景下，类A一般是高层模块，负责复杂的业务逻辑；类B和类C是低层模块，负责基本的原子操作；假如修改类A，会给程序带来不必要的风险。
解决方案：将类A修改为依赖接口I，类B和类C各自实现接口I，类A通过接口I间接与类B或者类C发生联系，则会大大降低修改类A的几率。
通俗的栗子：我们现在有个拖拉机A类，直接依赖于B类柴油，没有热能，没有办法带动机器运转呀，所以拖拉机的动能来源就是柴油燃烧产生的热能转换机器的动能，可是你光有发动机，没有轮子怎么耕地？所以现在A类有依赖C类这个轮子了，所以你的重新设计A类，并加上轮胎才能完成耕地的需求了，可是随着需求的变更，需要添加更多的拖拉机原件，耙犁，车斗等，A类就变得很庞杂，但是我们将A类编程一个借口I，让B类，C类，等元器件全部来实现A类的拖拉机所需要的全部的元器件，这样整个需求只需要添加接口，实现A类中复杂的逻辑了。

值得注意的是依赖倒置原则基于这样一个事实：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建起来的架构比以细节为基础搭建起来的架构要稳定的多。在java中，抽象指的是接口或者抽象类，细节就是具体的实现类，使用接口或者抽象类的目的是制定好规范和契约，而不去涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成。

下面我们来实战：
第一招：举例子

public class Function02 {
    public static void main(String[] arg0){
        Tractor tractor = new Tractor();
        tractor.dirver(new Oil());
    }
}

class Oil{
    public String getContent(){
        return "拖拉机的动力来源：柴油。。。。";
    }
}

class Tractor{
    public void dirver(Oil oil){
        System.out.println("老司机要开拖拉机了！");
        System.out.println(oil.getContent());
    }
}

运行结果：

老司机要开拖拉机了！
拖拉机的动力来源：柴油。。。。

但是这老司机开的是有轮子的拖拉机，但是这只有柴油发动机，没轮子怎么上路呢？

第二招：在举栗子：

public class Function02 {
    public static void main(String[] arg0){
        Tractor tractor = new Tractor();
        tractor.dirver(new Oil());
    }
}

class Oil{
    public String getContent(){
        return "拖拉机的动力来源：柴油。。。。";
    }
}

class Tyres{
    public String getContent(){
        return "拖拉机的动力输出：轮胎。。。。";
    }  
}

class Tractor{
    public void dirver(Oil oil){
        System.out.println("老司机要开拖拉机了！");
        System.out.println(oil.getContent());
    }
}

这可就难住老司机了，当初九没有设计轮胎安装位置，有轮胎也是枉然啦！怎么办呢？

第三招：拆了重来

public class Function02 {
    public static void main(String[] arg0){
        Tractor tractor = new Tractor();
        tractor.dirver(new Oil());
        tractor.dirver(new Tyres());
        System.out.println("看！老司机上路了。。。");
    }
}

interface ITractor{
        public String getContent();
}

class Oil implements ITractor{
    public String getContent(){
        return "拖拉机的动力来源：柴油。。。。";
    }
}

class Tyres implements ITractor{
    public String getContent(){
        return "拖拉机的动力输出：轮胎。。。。";
    }
}

class Tractor{
    public void dirver(ITractor iTractor){
        System.out.println("老司机要开拖拉机了！");
        System.out.println(iTractor.getContent());
    }
}

运行结果：

老司机要开拖拉机了！
拖拉机的动力来源：柴油。。。。
老司机要开拖拉机了！
拖拉机的动力输出：轮胎。。。。
看！老司机上路了。。。

这下进一步设计一个完美的拖拉机标准件接口ITractor，你什么我就装什么，老司机编程老师傅。。。

总结：

传递依赖关系有三种方式，以上的例子中使用的方法是接口传递，另外还有两种传递方式：构造方法传递和setter方法传递，相信用过Spring框架的，对依赖的传递方式一定不会陌生。
在实际编程中，我们一般需要做到如下3点：
    低层模块尽量都要有抽象类或接口，或者两者都有。
    变量的声明类型尽量是抽象类或接口。
    使用继承时遵循里氏替换原则。
依赖倒置原则的核心就是要我们面向接口编程，理解了面向接口编程，也就理解了依赖倒置。