设计模式七大原则三之依赖倒转原则，依赖关系传递的三种方式

基本介绍

1）高层模块不应该依赖底层模块，二者都应该依赖其抽象

2）抽象不应该依赖细节，细节应该依赖抽象

3）依赖倒转（倒置）的中心思想是面向接口编程

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

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

案例讲解

1）编写Person类，实现接收消息的功能

package com.hy.principle.inversion;

/**
 * @author hanyong
 * @date 2020/9/12 10:23
 */
public class DependcyInversion {
    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());
    }
}

//问题所在，当有微信，短信等传输信息的方式时需要重新建立实体类，再生成对应的方法，客户端调用也要区分不同的方式进行调用

class Email {
    public String getInfo() {
        return "电子邮件信息：hello email";
    }
}

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

提升版

package com.hy.principle.inversion.improve;

/**
 * @author hanyong
 * @date 2020/9/12 10:23
 */
public class DependcyInversion {
    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());
        person.receive(new WeiXin());
    }
}

interface Isender {
    public String getInfo();
}


class Email implements Isender {
    @Override
    public String getInfo() {
        return "电子邮件信息：hello email";
    }
}

class WeiXin implements Isender {

    @Override
    public String getInfo() {
        return "微信信息：hello 微信";
    }
}

//Person类由之前的依赖实体类到依赖接口，实体类实现发送的接口，客户端person只需要调用接口的方法，在调用的时候在具体区分
class Person {
    public void receive(Isender sender) {
        System.out.println(sender.getInfo());
    }
}

依赖关系传递的三种方式
1）接口传递
2）构造方法传递
3）setter方式传递

代码演示

package com.hy.principle.inversion.improve;

/**
 * @author hanyong
 * @date 2020/9/12 15:50
 */
public class DependcyPass {
    public static void main(String[] args) {
        ChangHong changHong = new ChangHong();
//        OpenAndClose openAndClose = new OpenAndClose();
//        openAndClose.open(changHong);

        /*OpenAndClose openAndClose = new OpenAndClose(changHong);
        openAndClose.open();*/

        OpenAndClose openAndClose = new OpenAndClose();
        openAndClose.setItv(changHong);
        openAndClose.open();
    }
}

//方式一通过接口传递实现依赖
class ChangHong implements Itv {

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

/*interface IOpenAndClose {
    public void open(Itv itv);
}

interface Itv {
    public void play();
}

class OpenAndClose implements IOpenAndClose {

    @Override
    public void open(Itv tv) {
        tv.play();
    }
}*/

//方式二通过构造函数实现以来传递
/*interface IOpenAndClose {
    public void open(); //抽象方法
}

interface Itv { //Itv接口
    public void play();
}

class OpenAndClose implements IOpenAndClose {

    public Itv tv; //成员

    public OpenAndClose(Itv tv) { //构造器
        this.tv = tv;
    }

    @Override
    public void open() {
        this.tv.play();
    }
}*/

//方式三通过setter的方式进行依赖传递

interface IOpenAndClose {
    public void open();

    public void setItv(Itv tv);
}

interface Itv {
    public void play();
}

class OpenAndClose implements IOpenAndClose {
    private Itv tv;

    @Override
    public void setItv(Itv tv) {
        this.tv = tv;
    }


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

依赖倒转原则
1）底层模块尽量都要有抽象类或接口，或两者都有，程序稳定性更好
2）变量的声明类型尽量是抽象类或接口，这样我们的变量引用和实际对象间，就存在一个缓冲区，利于程序扩展和优化
3）继承时遵循里氏替换原则