05 依赖倒置原则

官方定义：

依赖倒置原则（Dependence Inversion Principle，DIP）是指在设计代码架构
时，高层模块不应该依赖于底层模块，二者都应该依赖于抽象。抽象不应该依
赖于细节，细节应该依赖于抽象。

通俗解释

场景示例

希捷硬盘类（XiJieHardDisk）：

public class XiJieHardDisk implements HardDisk {
public void save(String data) {
System.out.println("使用希捷硬盘存储数据" + data);
}
public String get() {
System.out.println("使用希捷希捷硬盘取数据");
return "数据";
}
}
1
2
3
4
5
6
7
8
9

Intel处理器（IntelCpu）：

public class IntelCpu implements Cpu {
	public void run() {
		System.out.println("使用Intel处理器");
	}
}
1
2
3
4
5

金士顿内存条（KingstonMemory）：

public class KingstonMemory implements Memory {
	public void save() {
		System.out.println("使用金士顿作为内存条");
	}
}
1
2
3
4
5

电脑（Computer）：

public class Computer {
private XiJieHardDisk hardDisk;
private IntelCpu cpu;
private KingstonMemory memory;
public IntelCpu getCpu() {
return cpu;
}
public void setCpu(IntelCpu cpu) {
this.cpu = cpu;
}
public KingstonMemory getMemory() {
return memory;
}
public void setMemory(KingstonMemory memory) {
this.memory = memory;
}
public XiJieHardDisk getHardDisk() {
return hardDisk;
}
public void setHardDisk(XiJieHardDisk hardDisk) {
this.hardDisk = hardDisk;
}
public void run() {
System.out.println("计算机工作");
cpu.run();
memory.save();
String data = hardDisk.get();
System.out.println("从硬盘中获取的数据为：" + data);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

测试类（TestComputer）：用来组装电脑

public class TestComputer {
public static void main(String[] args) {
Computer computer = new Computer();
computer.setHardDisk(new XiJieHardDisk());
computer.setCpu(new IntelCpu());
computer.setMemory(new KingstonMemory());
computer.run();
}
}
1
2
3
4
5
6
7
8
9

上面代码可以看到已经组装了一台电脑，但是似乎组装的电脑的cpu只能是Intel
的，内存条只能是金士顿的，硬盘只能是希捷的，这对用户肯定是不友好的，
用户有了机箱肯定是想按照自己的喜好，选择自己喜欢的配件。

根据依赖倒转原则进行改进：

代码我们需要修改Computer类，让Computer类依赖抽象（各个配件的接
口），而不是依赖于各个组件具体的实现类。

public class Computer {
private HardDisk hardDisk;
private Cpu cpu;
private Memory memory;
//getter/setter......
public void run() {
System.out.println("计算机工作");
}
}
1
2
3
4
5
6
7
8
9

关于依赖倒置、依赖注入、控制反转这三者之间的区别与联系？

1 ) 依赖倒置原则

2 ) 控制反转

3 ) 依赖注入