【六大设计原则】迪米特法则

发表于

六大设计原则

单一职责原则

里氏替换原则

依赖倒置原则

接口隔离原则

迪米特法则

开放封闭原则

定义

一个对象应当对其他对象尽可能少的了解。

示例

Tom 和 David 是朋友，David 和 Eva 是朋友， Tom想和 Eva 做朋友的话必须通过 David 认识。

示例一

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
typescript复制代码public class Tom {

    public void play(David david){
        david.play();
    }

    public void play(Eva eva) {
        eva.play();
    }
}

public class David {

    public void play(){
        System.out.println("和 David 成为朋友");
    }
}

public class Eva {

    public void play(){
        System.out.println("和 Eva 成为朋友");
    }
}

public class Test {

    public static void main(String[] args) {
        Tom tom = new Tom();
        David david = new David();
        Eva eva = new Eva();

        tom.play(david);
        tom.play(eva);
    }
}

image.png

此示例实现了和Eva成为了朋友，但是Tom直接关联了Eva。

示例二

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
csharp复制代码public class Tom {

    public void play(David david){
        david.play();
        Eva eva = david.leadEva();
        eva.play();
    }
}

public class David {

    public void play(){
        System.out.println("和 David 成为朋友");
    }

    public Eva leadEva() {
        System.out.println("带领 Eva 过来");
        Eva eva = new Eva();
        return eva;
    }
}

public class Eva {

    public void play(){
        System.out.println("和 Eva 成为朋友");
    }
}

public class Test {

    public static void main(String[] args) {
        Tom tom = new Tom();
        David david = new David();
        tom.play(david);
    }
}

image.png

此方案实现了通过 David 和 Eva 成为了朋友，但是 Tom 中包含了对 Eva 的引用，不符合迪米特法则。

示例三

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
typescript复制代码public class Tom {

    private David david;

    public David getFriend() {
        return david;
    }

    public void setFriend(David david) {
        this.david = david;
    }

    public void play(David david){
        david.play();
    }
}

public class David {

    public void play(){
        System.out.println("和 David 成为朋友");
        playWithStranger();
    }

    public void playWithStranger() {
        Eva eva = new Eva();
        eva.play();
    }
}

public class Eva {

    public void play(){
        System.out.println("和 Eva 成为朋友");
    }
}

public class Test {

public static void main(String[] args) {
        Tom tom = new Tom();
        David david = new David();
        tom.setFriend(david);
        tom.play(david);
    }
}

image.png

此方案实现了与 Eva 毫无联系，并且成为了朋友。

示例四

结合依赖倒转原则，为 Eva 定义一个抽象。

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
csharp复制代码public class Tom {

    private David david;

    private Eva eva;

    public Tom(David david, Eva eva) {
        this.david = david;
        this.eva = eva;
    }

    public David getDavid() {
        return david;
    }

    public void setDavid(David david) {
        this.david = david;
    }

    public Eva getEva() {
        return eva;
    }

    public void setEva(Eva eva) {
        this.eva = eva;
    }

    public void play(){
        david.play();
        eva.play();
    }
}

public class David {

    public void play(){
        System.out.println("和 David 成为朋友");
    }
}

public abstract class AbstractEva {

    public abstract void play();
}

public class Eva extends AbstractEva {

    public void play(){
        System.out.println("和 Eva 成为朋友");
    }
}

public class Test {

    public static void main(String[] args) {
        Tom tom = new Tom(new David(), new Eva());
        tom.play();
    }
}

image.png

和 Tom 直接通信的是 Eva 的抽象父类，和 Eva 具体实现没有直接关系，所以符合迪米特法则。

总结

迪米特法则的核心观念就是类间解耦，弱耦合，只有弱耦合了以后，类的复用率才可以提升上去。但是，这也会造成系统的不同模块之间的通信效率降低，也会使系统的不同模块之间不容易协调。

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%