嘻哈说：设计模式之依赖倒置原则

一、定义

按照惯例，首先咱们来看一下依赖倒置原则的定义。

抽象不该该依赖于细节，细节应当依赖于抽象。 换言之，要针对接口编程，而不是针对实现编程。

为何要这样说呢？

由于细节具备易变性，很是的不稳定。不少时候，需求改变就会给细节带来改变。

而抽象则是相对稳定的，抽象是从众多的事物中抽取出共同的、本质性的特征，是比较难被改变的。

因此，咱们确定要选择对抽象编程，而不选择对细节编程。

抽象在Java中则指的是抽象类或者接口；细节则是表明着具体实现。

对接口编程，是写出健壮性代码的根本，是优秀程序员必备的基本素质。

二、含义

一、高层模块不该该依赖低层模块，二者都应该依赖其抽象

不管是高层模块，仍是低层模块，所有都属于具体的实现，属于细节，而细节确定是不能相互依赖的。

他们都应该依赖于抽象。

二、抽象不该该依赖细节

都不该该依赖于细节，特别是抽象更加不该该依赖细节。

三、细节应该依赖抽象

都应该依赖抽象，细节依赖抽象，抽象也依赖抽象。

三、代码

一、接口方法中声明依赖对象

package com.fanqiekt.principle.inversion;

/**
 * 厨师接口
 *
 * @author 番茄课堂-懒人
 */
public interface IChef {

    /**
     * 作饭
     */
    void cooking();
}
复制代码

厨师都会作饭。

package com.fanqiekt.principle.inversion;

/**
 * 四川厨师
 *
 * @author 番茄课堂-懒人
 */
public class SiChuanChef implements IChef {

    @Override
    public void cooking() {
        System.out.println("四川厨师作饭，多放辣椒。");
    }
}
复制代码

厨师的实现类，川菜厨师，其中的逻辑都属于细节，例如川菜厨师有本身作饭的套路（不能没有辣）。

package com.fanqiekt.principle.inversion;

/**
 * 山东厨师
 *
 * @author 番茄课堂-懒人
 */
public class ShanDongChef implements IChef {

    @Override
    public void cooking() {
        System.out.println("山东厨师作饭，用葱姜蒜。");
    }

}
复制代码

另外一个厨师的实现类，鲁系厨师，鲁菜厨师也有本身作饭的套路（善用葱姜蒜）。

package com.fanqiekt.principle.inversion;

public interface IWaiter {

    /**
     * 点餐
     * @param chef 指定作饭的菜系厨师
     */
    void order(IChef chef);
}
复制代码

服务员的抽象接口，服务员都须要为客人点餐。

order(IChef chef) 方法就是接口方法中声明依赖对象。

在接口中定义该方法，并将依赖的抽象对象做为参数传入。

package com.fanqiekt.principle.inversion;

/**
 * 接口方法中声明依赖对象
 *
 * @author 番茄课堂-懒人
 */
public class Waiter implements IWaiter{

    @Override
    public void order(IChef chef){
        if(chef!=null) {
            chef.cooking();
        }

    }

}
复制代码

服务员的实现类，点餐是让传入的厨师去作饭。

IChef sichuanChef = new SiChuanChef();
IChef shandongChef = new ShanDongChef();
IWaiter waiter = new Waiter();
waiter.order(sichuanChef);
waiter.order(shandongChef);
复制代码

将抽象对象做为order方法参数。

四川厨师作饭
山东厨师作饭
复制代码

运行结果。

每次调用方法时，都传入依赖对象。

优势是灵活，每次均可以传入不一样的依赖对象。

缺点是繁琐，每次都须要传入依赖对象。

二、构造方法传递依赖对象

package com.fanqiekt.principle.inversion;

public interface IWaiter {

    /**
     * 点餐
     */
    void cooking();
}
复制代码

服务员接口修改：cooking方法去掉参数。

package com.fanqiekt.principle.inversion;

/**
 * 构造方法传递依赖对象
 *
 * @author 番茄课堂-懒人
 */
public class Waiter implements IWaiter {

    private IChef chef;

    /**
     * 构造方法中传入依赖的抽象对象
     * @param chef 厨师抽象接口
     */
    public Waiter(IChef chef){
        this.chef = chef;
    }

    @Override
    public void cooking(){
        if(chef!=null) {
            chef.cooking();
        }
    }

}
复制代码

经过构造方法传入依赖的抽象对象。

Waiter waiter1 = new Waiter(sichuanChef);
waiter1.cooking();
Waiter waiter2 = new Waiter(shandongChef);
waiter2.cooking();
复制代码

运行看一下结果。

四川厨师作饭
山东厨师作饭
复制代码

首次建立的时候就肯定了依赖，既是优势又是缺点。

优势是避免了被修改。

缺点是更换依赖，就须要从新再建立对象了。

三、Setter方法传递依赖对象

package com.fanqiekt.principle.inversion;

/**
 * Setter方法传递依赖对象
 *
 * @author 番茄课堂-懒人
 */
public class Waiter implements IWaiter {

    private IChef chef;

    public void setChef(IChef chef){
        this.chef = chef;
    }

    @Override
    public void cooking(){
        if(chef!=null) {
            chef.cooking();
        }
    }

}
复制代码

经过set方法赋值依赖对象。

Waiter plan = new Waiter();
plan.setChef(sichuanChef);
plan.cooking();
plan.setChef(shandongChef);
plan.cooking();
复制代码

运行看一下结果。

四川厨师作饭
山东厨师作饭
复制代码

Setter既能够更换依赖对象，也不用每次调用方法时都传入依赖对象。

三、优势

咱们来总结一下依赖倒置原则的几个优势。

下降风险 依赖抽象，大大提升代码的健壮性，风险天然而然就被下降了。

易维护易扩展 依赖抽象，才会有框架，基于框架，扩展会更方便，维护起来也更省事。

增长开发速度 定好抽象结构就能够并行开发了，而不用过多的被他人的进度干预。

四、嘻哈说

接下来，请您欣赏依赖倒置原则的原创歌曲。

嘻哈说：依赖倒置原则
做曲：懒人
做词：懒人
Rapper:懒人

须要依赖厨师为我作顿美食
不用管他到底川系或者徽系
只依赖厨师接口作法多么美丽
否则修改起来牵扯太多的话是多么费事
set方法构造方法接口方法能够将依赖作个配置
依赖倒置原则就是这么回事
抽象不依赖细节 细节依赖抽象
高层不依赖低层 都应该依赖抽象
面向接口编程记住这点才能在代码路走的够长
易扩展易维护风险下降增长开发速度
就像番茄课堂同样酷
复制代码

试听请点击这里

闲来无事听听曲，知识已填脑中去；

学习复习新方式，头戴耳机不小觑。

番茄课堂，学习也要酷。