hooyantsing's Blog

P8 接口隔离原则

字数统计: 808阅读时长: 4 min
2020/11/06

尚硅谷Java设计模式(图解+框架源码剖析)

接口隔离原则

  1. 类A通过接口Interface1依赖类B,类C通过接口Interface1依赖类D,如果接口Interface1对于类A和类C来说不是最小接口,那么类B和类D必须去实现他们不需要的方法。
  2. 将接口Interface1拆分为独立的几个接口,类A和类B分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则。
  3. 接口Interface1中出现的方法,根据实际情况拆分为三个接口。
非接口隔离原则

不满足最小接口,实现类还要实现根本用不到的方法。

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
package xyz.hooy.principle.segregation;

public class Segregation1 {
}

interface Interface1 {
void operation1();
void operation2();
void operation3();
void operation4();
void operation5();
}

// B 只想实现接口 1 2 3 方法
class B implements Interface1{
@Override
public void operation1() {
System.out.println("B 实现了 operation1");
}

@Override
public void operation2() {
System.out.println("B 实现了 operation2");
}

@Override
public void operation3() {
System.out.println("B 实现了 operation3");
}

@Override
public void operation4() {
System.out.println("B 实现了 operation4");
}

@Override
public void operation5() {
System.out.println("B 实现了 operation5");
}
}

// D 只想实现接口 1 4 5 方法
class D implements Interface1{
@Override
public void operation1() {
System.out.println("D 实现了 operation1");
}

@Override
public void operation2() {
System.out.println("D 实现了 operation2");
}

@Override
public void operation3() {
System.out.println("D 实现了 operation3");
}

@Override
public void operation4() {
System.out.println("D 实现了 operation4");
}

@Override
public void operation5() {
System.out.println("D 实现了 operation5");
}
}

// A 依赖接口 1 2 3 方法
class A {
public void depend1(Interface1 i){
i.operation1();
}
public void depend2(Interface1 i){
i.operation2();
}
public void depend3(Interface1 i){
i.operation3();
}
}

// C 依赖接口 1 4 5 方法
class C {
public void depend1(Interface1 i){
i.operation1();
}
public void depend4(Interface1 i){
i.operation4();
}
public void depend5(Interface1 i){
i.operation5();
}
}
接口隔离原则

将原来的接口拆分成三个更细的接口。

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
package xyz.hooy.principle.segregation.improve;

public class Segregation2 {
public static void main(String[] args) {
A a = new A();
a.depend1(new B()); // A 通过接口去依赖(使用) B
a.depend2(new B());
a.depend3(new B());

C c = new C();
c.depend1(new D()); // C 通过接口去依赖(使用) D
c.depend4(new D());
c.depend5(new D());
}
}

interface Interface1 {
void operation1();
}

interface Interface2 {
void operation2();
void operation3();
}

interface Interface3 {
void operation4();
void operation5();
}


// B 只想实现接口 1 2 3 方法
class B implements Interface1,Interface2{
@Override
public void operation1() {
System.out.println("B 实现了 operation1");
}

@Override
public void operation2() {
System.out.println("B 实现了 operation2");
}

@Override
public void operation3() {
System.out.println("B 实现了 operation3");
}
}

// D 只想实现接口 1 4 5 方法
class D implements Interface1,Interface3{
@Override
public void operation1() {
System.out.println("D 实现了 operation1");
}

@Override
public void operation4() {
System.out.println("D 实现了 operation4");
}

@Override
public void operation5() {
System.out.println("D 实现了 operation5");
}
}

// A 依赖接口 1 2 3 方法
class A {
public void depend1(Interface1 i){
i.operation1();
}
public void depend2(Interface2 i){
i.operation2();
}
public void depend3(Interface2 i){
i.operation3();
}
}

// C 依赖接口 1 4 5 方法
class C {
public void depend1(Interface1 i){
i.operation1();
}
public void depend4(Interface3 i){
i.operation4();
}
public void depend5(Interface3 i){
i.operation5();
}
}
CATALOG
  1. 1. 接口隔离原则
    1. 1.1. 非接口隔离原则
    2. 1.2. 接口隔离原则