1、5迪米特法则

定义

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

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

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

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

四层含义

只和朋友交流

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

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

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

案例1-1

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(优化)

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

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(优化)

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.那才是完全解耦，在实际的项目中，需要适度地考虑这个原则，别为了套用原则而做项目。需反复度量，不遵循是不对的，严格执行就是“过犹不及”。

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