设计模式七大原则依赖倒转原则

基本介绍：

依赖原则是指：

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

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

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

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

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

应用实例：

Person接受消息的功能

方式一：

package cn.rabcheng.dependenceinversion;

/**
 * @auther cheng
 * @create 2020-08-13 22:41
 * 依赖倒转原则
 */
public class dependenceinversion1 {
    public static void main(String[] args) {

        Person person = new Person();
        person.receive(new Email());
        person.receive2(new Weixin());


    }
}

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

class Weixin{
    public String getInfo(){
        return "微信消息：hello ok";
    }
}

//完成Person接受消息的功能
class Person{
    public void receive(Email email){
        System.out.println(email.getInfo());
    }

    public void receive2(Weixin weixin){
        System.out.println(weixin.getInfo());

    }
}

电子邮件信息：hello world
微信消息：hello ok

方式一的分析：

简单，比较容易想到、实现

如果我们获取的对象是微信、短信等等，则新增类，同时Person也要增加相应的接受方法

解决思路：引入一个抽象的接口IReceiver，表示接收者，这样Person类与IReceiver发生依赖

因为Email，Weixin等等属于接收的范围，他们各自实现IReceiver接口就行，这样我们就符合依赖倒转的原则

方式二：

package cn.rabcheng.dependenceinversion;

/**
 * @auther cheng
 * @create 2020-08-13 22:57
 * 依赖倒转原则
 */
public class dependenceinversion2 {
    public static void main(String[] args) {

        //客户端无需改变
        Person2 person2 = new Person2();
        person2.receive(new Email2());
        person2.receive(new Weixin2());


    }
}

//定义接口
interface IReceiver{
    String getInfo();
}


class Email2 implements IReceiver{
    @Override
    public String getInfo() {
        return "电子邮件信息：hello world";
    }
}

//增加微信
class Weixin2 implements IReceiver{
    @Override
    public String getInfo() {
        return "微信消息：hello ok";
    }
}

class Person2{
    //person2依赖接口
    public void receive(IReceiver iReceiver){
        System.out.println(iReceiver.getInfo());
    }
}
电子邮件信息：hello world
微信消息：hello ok

这样只需要增加Weixin类，不用增加Person类里面的方法，让Person类和IReceiver发生依赖关系。

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

接口传递

构造方法传递

setter方法传递

package cn.rabcheng.dependenceinversion;

/**
 * @auther cheng
 * @create 2020-08-13 23:10
 * 依赖传递
 */
public class DependencyPass {
    public static void main(String[] args) {

//        方式一：通过接口传递
//        Open open = new Open();
//        open.open(new XiaoMi());

//        方式二：通过构造方法传递
//        Open open = new Open(new XiaoMi());
//        open.open();

//        方式三：通过setter方法传递
        Open open = new Open();
        XiaoMi xiaoMi = new XiaoMi();
        open.setter(xiaoMi);
        open.open();
    }
}

//方式一：通过接口传递依赖
//开电视的接口
//interface IOpen{
//    void open(ITV itv);
//}
//
////电视机接口
//interface ITV{
//    void play();
//}
//
//class XiaoMi implements ITV{
//    @Override
//    public void play() {
//        System.out.println("小米电视，打开");
//    }
//}
//
//class Open implements IOpen{
//    @Override
//    public void open(ITV itv) {
//        itv.play();
//    }
//}

//方式二：通过构造方法传递依赖
//interface IOpen{
//    void open();
//}
//
//interface ITV{
//    void play();
//}
//
//class XiaoMi implements ITV{
//    @Override
//    public void play() {
//        System.out.println("小米电视，打开");
//    }
//}
//
//class Open implements IOpen{
//    private ITV itv;
//    public Open(ITV itv) {
//        this.itv = itv;
//    }
//
//    @Override
//    public void open() {
//        this.itv.play();
//    }
//}


//方式三：通过setter方法传递
interface IOpen{
    void open();
}

interface ITV{
    void play();
}

class Open implements IOpen{
    private ITV itv;

    public void setter(ITV itv){
        this.itv = itv;
    }
    @Override
    public void open() {
        this.itv.play();
    }
}

class XiaoMi implements ITV{
    @Override
    public void play() {
        System.out.println("小米电视，打开");
    }
}

依赖倒转原则的注意事项和细节：

底层模块尽量都要有抽象类或接口，或者两者都有，程序稳定性更好

变量的声明类型尽量是抽象类或接口，这样我们的变量引用和实际对象间，就存在一个缓冲层，利于程序扩展和优化

继承时应遵循里氏替换原则