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

六大设计原则

单一职责原则

里氏替换原则

依赖倒置原则

接口隔离原则

迪米特法则

开放封闭原则

定义

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

示例

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

示例一

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);
    }
}
复制代码

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

示例二

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);
    }
}
复制代码

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

示例三

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);
    }
}
复制代码

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

示例四

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

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();
    }
}
复制代码

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

总结

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