迪米特法则

什么是迪米特法则

迪米特法则(Law of Demeter, LoD),又被称为最少知识原则，这个原则规定了，一个对象应该对另一个对象有最少的了解，什么又是最少的了解，就是减少一个对象在另一个对象出现的次数，甚至不出现，减少类于类之间的耦合关系。
一个类对另一个类的了解，都是基于其public方法。
迪米特法则还有一个英文解释：Only talk to your immediate friends,只于一个类之间的朋友进行交流。
什么是类于类之间的交流？无非就是一个类中的方法中调用另一个类的方法。
什么是直接朋友？一个类的朋友就是这个类本身、这个类的成员对象、这个对象创建的对象、当前对象的方法参数等等。
参考如下代码，Address,Book,Stuent这些都是Teacher的朋友。

public class Teacher {    private Address address;    public void tech(Book book){        System.out.println(book.getName);    }    public Studnet findStudent(){        return Student();    }}

只和朋友交流

如何做到之和朋友类交流，来看一个案例：
老师想让班长去清点一下班级的人数，让我们用代码去实现这个场景;
先看类图：

代码：

public class Student {}public class Teacher {    void command(Monitor monitor){        List<Student> listStudent = new ArrayList<>();        for (int i=0; i<3; i++){            listStudent.add(new Student());        }        monitor.countStudent(listStudent);    }}public class Monitor {    void countStudent(List<Student> list){        System.out.println("学生人数：" + list.size());    }}public class Client {    public static void main(String[] args) {        Teacher teacher = new Teacher();        teacher.command(new Monitor());    }}

运行结果：

运行结果很成功，学生人数被统计出来了。
但是这样的设计有什么问题？
首先Teacher类有几个朋友类，只有Monitor类（成员变量），那这里Student类是它的朋友类吗？不是，Student类是在方法中产生的，不是朋友类，但它却出现在了Teacher类中，这就相当于和Teacher类产生了交流，产生了依赖，这样回导致，如果以后Student类发生了改变，Teacher类也得同步参数修改，这是严重不允许的，严重违反迪米特法则。
让我们去修改一下这个类图结构：

public class Student {}public class Monitor {    private List<Student> list;    public Monitor(List<Student> list) {        this.list = list;    }    void countStudent(){        System.out.println("学生人数：" + list.size());    }}public class Teacher {    void command(Monitor monitor){        monitor.countStudent();    }}public class Client {    public static void main(String[] args) {        Teacher teacher = new Teacher();        List<Student> listStudent = new ArrayList<>();        for (int i=0; i<3; i++){            listStudent.add(new Student());        }        teacher.command(new Monitor(listStudent));    }}

观察改进前和改进后的代码有什么区别，改进前，Monitor类需要统计Student类，需要一个List,通过它的上级调用类，也就是Teacher类创建得到，虽然完成了业务，但是却导致Teacher类和它的非朋友类Student产生了交流，以后如果Student类有改动，Teacher类也会跟着改，于是进行修改，把Monitor类和Studnet类的依赖用成员变量的方式进行依赖，通过构造方法进行传递，这样Teacher类就可以不用和Studnet类进行交流，就能完成业务了。

朋友之间交流也不要太密切

迪米特法则中规定，一个类中，只与这个类的朋友进行联系，说简单点，就是一个类的方法中，如果一个类不是这个类的成员变量、函数参数、或者这个类通过方法创建出来的，最好不要出现在这个方法中。
但是，即使这个某个类是这个类的朋友，也应该尽可能的减少交流，也就是调用。
比如说，我们的电脑要安装一个软件，是不是要点击软件包，然后一直点下一步，如果某一步失败，后续的步骤也不能继续往下执行了。
来用代码表示是什么样的？

public class Install {    int checkDir(){        System.out.println("检查目录");        return 1;    }    int checkSpace(){        System.out.println("检查空间");        return 1;    }    int install(){        System.out.println("安装软件");        return 1;    }}public class Computer {    private Install install;    public Computer(Install install) {        this.install = install;    }    void installSoftWare(){        //检查目录是否存在        int i = install.checkDir();        if (i==1){            //检查空间是否足够            int i1 = install.checkSpace();            if (i1==1){                int install = this.install.install();                if (install==1){                    System.out.println("安装成功");                    return;                }else {                    System.out.println("安装失败");                    return;                }            }        }        System.out.println("安装失败");    }}

仔细看Computer类安装的方法，它和之间的朋友类Install进行交流，每次步骤返回1，代表成功，就进行下一步。这样的代码也许能模拟这个业务，但是它有什么问题？我们得考虑以后代码变动的风险，如果以后，每个安装步骤的返回值，不在返回1代表成功，而是布尔类型的true代表成功，这样回导致Computer类所有对这些方法调用的地方都得修改。
为了改进这种情况，我们需要对类结构进行修改，如下：

public class Install {    private int checkDir(){        System.out.println("检查目录");        return 1;    }    private int checkSpace(){        System.out.println("检查空间");        return 1;    }    private int install(){        System.out.println("安装软件");        return 1;    }    public void installSoftForComputer(){        int i = checkDir();        if (i==1){            //检查空间是否足够            int i1 = checkSpace();            if (i1==1){                int install = install();                if (install==1){                    System.out.println("安装成功");                    return;                }else {                    System.out.println("安装失败");                    return;                }            }        }        System.out.println("安装失败");    }}public class Computer {    private Install install;    public Computer(Install install) {        this.install = install;    }    void installSoftWare(){        //检查目录是否存在        install.installSoftForComputer();    }}

看到改变前后的区别了吗？我把之前computer需要一个一个去调用的方法，封装在了Install一个public方法中，并且把每个安装步骤都设置为私有，这样有什么好处？我们减少了类与类之间的交流，同时也减少了它们变更带了的风险，以后Install类的变更，比如变更返回类型，那也只对Install内部有影响，这就是我们常说的高内聚！