1.高层模块不应该依赖底层模块 二者都应该依赖其抽象
2.抽象不应该依赖细节，细节应该依赖抽象
3.依赖倒置的中心思想是面向接口编程

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

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

方式1：

public class DependenceInversion {
}
class Email{
    public String getInfo(){
        return "helloworld";
    }
}
//Person类的receive方法是接受电子邮件
class Person{
    public void receive(Email email){
        System.out.println(email.getInfo());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

以上代码中 Person必须依赖于Email 此时高层模块（Person）依赖于底层模块（Email）
如果我们获取的对象是微信 短信等等 需要直接新增接受方法并且新增类
不利于代码的维护

解决思路：引入一个抽象接口IReceiver表示接收者 这样Person与接口发生依赖
因为Email，WeiXin等都属于接收者范围，他们各自实现IReceiver就可以了
这样就符合依赖倒置原则

**改进后：方式2**
1

public class DependenceInversion {
}

class Person{
    public void receive(IReceiver receiver){
        System.out.println(receiver.getInfo());
    }
}
interface IReceiver{
    public String getInfo();
}
class Email implements IReceiver{

    @Override
    public String getInfo() {
        return "helloworld";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

依赖关系传递的三种方式：

1.接口传递 2.构造方法传递 3.setter方式传递

1.接口传递

//1.通过接口传递实现依赖
//开关接口
interface  ITV{
    public void play();
}
interface IOpenAndClose{
    public void open(ITV tv);
}
class OpenAndClose implements IOpenAndClose{
    @Override
    public void open(ITV tv) {
        tv.play();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.构造方法传递

//2.通过构造方法实现依赖传递
//开关接口
interface  ITV{
    public void play();
}
interface IOpenAndClose{
    public void open();
}
class OpenAndClose implements IOpenAndClose{
    public ITV tv;
    public OpenAndClose(ITV tv){
        this.tv=tv;
    }
    @Override
    public void open() {
       tv.play();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

3.setter传递

//3.通过setter方法传递
//开关接口
interface  ITV{
    public void play();
}
interface IOpenAndClose{
    public void open();
    public void setTv(ITV tv);
}
class OpenAndClose implements IOpenAndClose{
private ITV tv;

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

    @Override
    public void setTv(ITV tv) {
        this.tv=tv;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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

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