YAZONG 我的开源

设计模式-六大设计原则(五)-迪米特法则

 
0 评论0 浏览

1、5迪米特法则

定义

迪米特法则也称为最少知识原则:一个对象应该对其他对象有最少的了解。(如果两个类不必彼此直接通信,那么这两个类就不应当发生直接的相互作用。如果其中一个类需要调用另一个类的某一个方法的话,可以通过第三者转发这个调用。)

迪米特法则首先强调的是在类的结构设计上,每一个类都应当尽量降低成员的访问权限。

迪米特法则其根本思想,是强调了类之间的松耦合。类之间的耦合越弱,越有利于复用;一个处在弱耦合的类被修改,不会对有关系的类造成波及。也就是说,信息的隐藏促进了软件的复用。

面向对象的设计原则和面向对象的三大特性本就不是矛盾的。

四层含义

只和朋友交流

方法是类的一个行为,类竟然不知道自己的行为与其他类产生依赖关系,这是不允许的,严重违反了迪米特法则。

注意:一个类只和朋友交流,不与陌生类交流,不要出现getA().getB().getC().getD()这种情况(在一种极端的情况下允许出现这种访问,即每一个点号后面的返回类型都相同),类与类之间的关系是建立在类间的,而不是方法间,因此一个方法尽量不引入一个类中不存在的对象,当然,JDK-API提供的类除外。

朋友类的定义是这样的:出现在成员变量、方法的输入输出参数中的类称为朋友类,而出现在方法体内部的类不属于朋友类。

案例1-1

image.png

public class Client1 {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        teacher.commond(new GroupLeader());
    }
}
class Girl{}
class GroupLeader{
    public void countGirls(List<Girl>listGirls){
        System.out.println("女生数量是:" + listGirls.size());
    }
}
class Teacher{
    public void commond(GroupLeader groupLeader){
        List<Girl> girlList = new ArrayList<Girl>();
        for (int i = 0; i < 20; i++) {
            girlList.add(new Girl());
        }
        groupLeader.countGirls(girlList);
    }
}

案例1-2(优化)

image.png

public class Client2 {
public static void main(String[] args) {
    #降低系统间的耦合,提高了系统的健壮性。
        List<Girl> girlList = new ArrayList<Girl>();
        for (int i = 0; i < 20; i++) {
            girlList.add(new Girl());
        }
        Teacher teacher = new Teacher();
        teacher.commond(new GroupLeader(girlList));
    }
}
class Girl{}
class GroupLeader{
    private List<Girl> girlList;
    public GroupLeader(List<Girl> girlList) {
        this.girlList = girlList;
    }
    public void countGirls(){
        System.out.println("女生数量是:" + this.girlList.size());
    }
}
class Teacher{
    public void commond(GroupLeader groupLeader){
        groupLeader.countGirls();
    }
}

朋友间也是有距离的

尽量不要对外公布太多的public方法和非静态的public变量,尽量内敛,多使用private、package-private、protected等访问权限。

首先来解释一下什么是直接的朋友:每个对象都会与其他对象有耦合关系,只要两个对象之间有耦合关系,我们就说这两个对象之间是朋友关系。耦合的方式很多,依赖、关联、组合、聚合等。其中,我们称出现成员变量、方法参数、方法返回值中的类为直接的朋友,而出现在局部变量中的类则不是直接的朋友。也就是说,陌生的类最好不要作为局部变量的形式出现在类的内部。

案例2-1

image.png

public class Client3 {
    public static void main(String[] args) {
        InstallSoftware invoker = new InstallSoftware();
        invoker.installWizard(new Wizard());
    }
}
class Wizard{
    private Random random = new Random(System.currentTimeMillis());
    public int first(){
        int firstVal = random.nextInt(100);
        System.out.println("执行第一个方法" + firstVal);
        return firstVal;
    }
    public int second(){
        int secondVal = random.nextInt(100);
        System.out.println("执行第二个方法" + secondVal);
        return secondVal;
    }
    public int third(){
        int thirdVal = random.nextInt(100);
        System.out.println("执行第三个方法" + thirdVal);
        return thirdVal;
    }

}
class InstallSoftware{
    public void installWizard(Wizard wizard){
        int firstVal = wizard.first();
        if(firstVal > 50){
            int secondVal = wizard.second();
            if(secondVal > 50){
                int thirdVal = wizard.third();
                if(thirdVal > 50){
                    wizard.first();
                }
            }
        }
    }
}

案例2-2(优化)

image.png

public class Client4 {
    public static void main(String[] args) {
        InstallSoftware invoker = new InstallSoftware();
        invoker.installWizard(new Wizard());
    }
}

class Wizard{
    private Random random = new Random(System.currentTimeMillis());
    public int first(){
        int firstVal = random.nextInt(100);
        System.out.println("执行第一个方法" + firstVal);
        return firstVal;
    }
    public int second(){
        int secondVal = random.nextInt(100);
        System.out.println("执行第二个方法" + secondVal);
        return secondVal;
    }
    public int third(){
        int thirdVal = random.nextInt(100);
        System.out.println("执行第三个方法" + thirdVal);
        return thirdVal;
    }
    public void installWizard(){
        int firstVal = this.first();
        if(firstVal > 50){
            int secondVal = this.second();
            if(secondVal > 50){
                int thirdVal = this.third();
                if(thirdVal > 50){
                    this.first();
                }
            }
        }
    }

}

class InstallSoftware{
public void installWizard(Wizard wizard){
#降低系统间的耦合,提高了系统的健壮性。
        wizard.installWizard();
    }
}

迪米特法则要求类”羞涩”一点,尽量不要对外公布田铎的public方法和非静态的public变量,尽量内敛,多使用private、package-private、protected等访问权限。

是自己的就是自己的

在实际应用中经常会出现这样一个方法:放在本类中也可以,放在其他类中也没有错,那么衡量的原则是:如果一个方法放在本类中,既不增加类间关系,也对本来不产生负面影响,那就放置在本类中。

谨慎使用Serializable

比如项目中使用RMI(远程方法调用),定义的一个VO必须实现Serializable接口(仅仅是一个标志性接口,不需要实现具体的方法),也就是把需要网络传输的对象进行序列化,否则就会出现NotSerializableException异常,突然某天,客户端把VO中的某个字段的访问权限从private设置成了public,而服务器上没有做变更,就会报序列化失败。

总结

迪米特法则的核心观念就是类间解耦,弱耦合,只有弱耦合了以后,类的复用率才可以提高。其要求的结果就是产生了大量的中转或跳转类,导致系统的复杂性提高,同时也为维护带来了难度。所以在使用迪米特法则时需要反复权衡,既做到让结构清晰,又做到高内聚低耦合。

在实际应用中,如果一个类跳转两次以上才能访问到另一个类,就需要想办法进行重构了,为什么是两次以上呢?因为一个系统的成功不仅仅是一个标准或是原则就能够决定的,有非常多的外在因素决定,跳转次数越多,系统越复杂,维护就越困难,所以只要跳转不超过两次都是可以忍受的,这需要具体问题具体分析。

迪米特法则要求类间解耦,但解耦是有限度的,除非是计算机的最小单元----二进制的0和1.那才是完全解耦,在实际的项目中,需要适度地考虑这个原则,别为了套用原则而做项目。需反复度量,不遵循是不对的,严格执行就是“过犹不及”。

过分的使用迪米特原则,会产生大量这样的中介和传递类,导致系统复杂度变大。所以在采用迪米特法则时要反复权衡,既做到结构清晰,又要高内聚低耦合。


标题:设计模式-六大设计原则(五)-迪米特法则
作者:yazong
地址:https://blog.llyweb.com/articles/2020/03/23/1584918988272.html