七大设计原则-依赖传递原则

前言

设计模式相关文章主要来自B站尚硅谷的学习视频的心得 B站视频传送门

设计模式系列文章传送门23种设计模式系列合集

有空会慢慢更新学习心得，相关源码在 Github

---

基本介绍

依赖倒转原则(Dependence Inversion Principle)是指：

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

• 抽象不应该依赖细节，细节应该依赖抽象

• 依赖倒转(倒置)的中心思想是面向接口编程

• 依赖倒转原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的 架构要稳定的多。在 java 中，抽象指的是接口或抽象类，细节就是具体的实现类

• 使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成

应用实例

• 实现方案 1 + 分析说明

package learn.lhb.design.patterns.principle.inversion;

/**
 * 依赖倒转原则案例 1
 * 有缺陷，解决方案看下面
 *
 * @author 梁鸿斌
 * @date 2020/3/16.
 * @time 21:29
 */
public class DependecyInversion1 {

    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());
    }
}

/**
 * 电子邮件类
 */
class Email {
    public String getInfo() {
        return "电子邮件信息: 你好";
    }
}

/**
 * // 完成接受消息的功能
 * // 方式一完成
 * 1. 简单，比较容易想到
 * 2. 如果获取对象是微信，短信等等，则需要新增对应的类，同时Person类也要增加相应的接收方法
 * 3. 解决思路： 引入一个抽象的接口，IReceiver，表示接收者，这样Person类与接口IReceiver发生依赖
 *      因为Email WeChat 等等都是接收的范围，他们仅需要各自实现IReceiver 接口即可，这样就符合依赖倒转原则
 *
 */
class Person {

    public void receive(Email email) {
        System.out.println(email.getInfo());
    }
}

实现方案 2(依赖倒转) + 分析说明

package learn.lhb.design.patterns.principle.inversion.improve;

/**
 * 依赖倒转原则案例 2
 *
 * @author 梁鸿斌
 * @date 2020/3/16.
 * @time 21:37
 */
public class DependecyInversion2 {

    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());
        person.receive(new WeChat());
    }
}


/**
 * 定义接口
 */
interface IReceiver {
    /**
     * 抽象方法
     * @return
     */
    public String getInfo();
}

/**
 * 电子邮件类
 */
class Email implements IReceiver {

    @Override
    public String getInfo() {
        return "电子邮件信息: 你好";
    }
}

/**
 * 增加微信
 */
class WeChat implements IReceiver {

    @Override
    public String getInfo() {
        return "微信信息: 你好";
    }
}

/**
 * // 完成接受消息的功能
 * // 方式2
 *
 */
class Person {

    public void receive(IReceiver iReceiver) {
        System.out.println(iReceiver.getInfo());
    }
}

依赖关系传递的三种方式和应用案例

• 接口传递
• 构造方法传递
• setter方法传递
• 代码演示

package learn.lhb.design.patterns.principle.inversion.improve;

/**
 * 依赖传递原则的三种实现方式
 * 1. 通过接口传递
 * 2. 通过构造方法传递
 * 3. 通过setter属性传递
 *
 * @author 梁鸿斌
 * @date 2020/3/16.
 * @time 21:48
 */
public class DependencyPass {
    public static void main(String[] args) {
        /**
         * 方法一的使用，接口Å
         */
        ChangHong changHong = new ChangHong();
        OpenAndClose openAndClose = new OpenAndClose();
        openAndClose.open(changHong);

        /**
         * 方法二的使用,构造方法
         */
        XiMenZi xiMenZi = new XiMenZi();
        OpenAndClose2 openAndClose2 = new OpenAndClose2(xiMenZi);
        openAndClose2.open();

        /**
         * 方法3 的使用, setter
         */
        SanXing sanXing = new SanXing();
        OpenAndClose3 openAndClose3 = new OpenAndClose3();
        openAndClose3.setTv(sanXing);
        openAndClose3.open();

    }
}

/**
 * 方式1： 通过接口传递实现依赖
 * 开关的接口
 */
interface IOpenAndClose {
    /**
     * 抽象方法，接收接口
     * @param tv
     */
    public void open(ITV tv);
}
/**
 * ITV接口
 */
interface ITV {
    public void play();
}
/**
 * 实现接口
 */
class OpenAndClose implements IOpenAndClose {
    @Override
    public void open(ITV tv) {
        tv.play();
    }
}
class ChangHong implements ITV {

    @Override
    public void play() {
        System.out.println("打开长虹电视机");
    }
}



/**
 * 方式2 通过构造方法传递依赖
 */
interface IOpenAndClose2 {
    /**
     * 抽象方法
     */
    public void open();
}
interface ITV2 {
    /**
     * ITV2 接口
     */
    public void play();
}
class OpenAndClose2 implements IOpenAndClose2 {
    /**
     * 成员
     */
    public ITV2 itv2;

    @Override
    public void open() {
        this.itv2.play();
    }

    /**
     * 构造器
     * @param itv2
     */
    public OpenAndClose2(ITV2 itv2) {
        this.itv2 = itv2;
    }
}
class XiMenZi implements ITV2 {

    @Override
    public void play() {
        System.out.println("打开西门子电视机");
    }
}

/**
 * 方式3 ， 通过setter方法传递
 */
interface IOpenAndClose3 {
    /**
     * 抽象方法
     */
    public void open();

    public void setTv(ITV3 tv);
}
interface ITV3 {
    public void play();
}
class OpenAndClose3 implements IOpenAndClose3 {
    private ITV3 itv3;

    @Override
    public void open() {
        this.itv3.play();
    }

    @Override
    public void setTv(ITV3 tv) {
        this.itv3 = tv;
    }
}
class SanXing implements ITV3 {

    @Override
    public void play() {
        System.out.println("打开三星电视机");
    }
}

---

有问题欢迎私信/评论指出，谢谢您的观看，希望对您有帮助哦！
https://lianghongbin.blog.csdn.net/