迪米特原则定义

迪米特原则，也叫最少知道原则，即一个类应该对自己依赖的类知道的越少越好，而你被依赖的类多么复杂，对我都没有关系。也就是说，对于别依赖的类来说，不管业务逻辑多么复杂，都应该尽量封装在类的内部；对外除了必备的public方法，不再泄露任何信息。

1.问题由来

我们知道，类和类是有耦合关系的，关系越密切的两个类之间，其耦合关系越大。

2.对应措施

迪米特原则要求：一个类应该只和之间的直接朋友通信。

1.直接朋友的定义

在上面我们提到了“直接朋友”这个概念，其实，在一个程序对象中，每个类都会和其他类有耦合关系，不然也就没有必要存在了。耦合的方式包括：依赖、关联、组合、聚合等。我们说，有耦合关系的两个类之间的关系，就是朋友关系。
那么，什么是“直接朋友”呢？
例如a类和b类具有耦合关系，若a类作为b类的成员变量、方法的形参、返回值，则说这两个类就是直接朋友；若a类作为b类的方法内的局部变量，则a类就不是b类的直接朋友。也就是说，陌生的类最好不要以局部变量的形式出现在类的内部。

3.应用实践

迪米特原则要求我们做到以下四点：

1.只和直接朋友沟通

为了说明这点，我们需要一个例子：比如在一所大学内有各个学院，现在要求打印出各个学院和学校总部的员工id。代码演示如下：

 public class demeter1 {
    public static void main(string[] args) {
        schoolmanager schoolmanager = new schoolmanager();
        schoolmanager.printallemp(new collegemanager());
    }
}

class schoolmanager {
    public void printallemp(collegemanager collegemanager) {
        list<employee> emplist = this.getallemployee();
        system.out.println("打印学校总部的员工");
        for (employee employee: emplist) {
            employee.printid();
        }
         //分析问题
    //1. 这里的 collegeemployee 不是  schoolmanager的直接朋友
    //2. collegeemployee 是以局部变量方式出现在 schoolmanager
        //3. 违反了 迪米特法则 
        list<collegeemployee> collegeemplist = collegemanager.getallemployee();
        system.out.println("打印学院员工");
        for (collegeemployee collegeemployee: collegeemplist) {
            collegeemployee.printid();
        }
    }

    //返回所用总部信息
    public list<employee> getallemployee() {
        list<employee> list = new arraylist<>();
        //添加5名总部的员工
        for (int i=0; i<5;i++) {
            employee employee = new employee();
            employee.setid(i);
            list.add(employee);
        }
        return list;
    }
}

//学院员工的管理类
class collegemanager {
    //返回学院的所有员工
    public list<collegeemployee> getallemployee() {
        list<collegeemployee> list = new arraylist<>();
        //添加10名学院员工
        for (int i = 0; i < 10; i++) {
            collegeemployee emp = new collegeemployee();
            emp.setid(i);
            list.add(emp);
        }
        return list;
    }
}

//学校员工类
class employee {
    private integer id;

    public integer getid() {
        return id;
    }

    public void setid(integer id) {
        this.id = id;
    }

    public void printid() {
        system.out.println("学校员工，id=" + this.getid());
    }
}

//学院员工类
class collegeemployee {
    private integer id;

    public integer getid() {
        return id;
    }

    public void setid(integer id) {
        this.id = id;
    }

    public void printid() {
        system.out.println("学院员工，id=" + this.getid());
    }
}

根据上面的代码，我们来找一下类schoolmanager的直接朋友：employee、collegemanager，而collegeemployee 是以局部变量方式出现在 schoolmanager，这就违背了“迪米特原则”。

改进措施

既然如此，我们就要将collegeemployee从schoolmanager类中抽离出来，使其不被依赖。
在collegemanager中增加一个打印学院员工的方法printcollegeemps()，这样，schoolmanager就只需调用这个方法就行了。

  public void printcollegeemps() {
        list<collegeemployee> list = this.getallemployee();
        for (collegeemployee collegeemployee: list) {
            collegeemployee.printid();
        }
    }

2.和朋友也要保持适当距离

看到这里你可能会困惑，既然已经要求我们做到：一个类只和直接朋友沟通，那么为什么还要保持距离呢？还是举例说明：现在有两个类a、b，类a中有三个public方法，类b需要调用a中的三个方法来完成一个流程：

public class demeter2 {
    public static void main(string[] args) {
        a a = new a();
        b b = new b();
        b.invokera(a);
    }
}

class a {
    public void method1() {
        system.out.println("执行第一个方法");
    }

    public void method2() {
        system.out.println("执行第二个方法");
    }

    public void method3() {
        system.out.println("执行第三个方法");
    }

}

class b {
    public void invokera(a a) {
        system.out.println("调用a的buildmethod()...");
        a.method1();
        a.method2();
        a.method3();
    }
}

ok，功能完成了，但是，类b需要依次调用类a的三个方法，需要保持三个方法对类b都是可见的。也就是说，类b和类a的耦合度太高了，我们可以改善一下两者的关系，适度的降低一下耦合度。在类a中定义一个public方法，来封装类b的逻辑，其余方法设置为private。

 //类a的相应修改
 private void method1() {
        system.out.println("执行第一个方法");
    }

    private void method2() {
        system.out.println("执行第二个方法");
    }

    private void method3() {
        system.out.println("执行第三个方法");
    }

    public void buildmethod() {
        system.out.println("流程开始");
        method1();
        method2();
        method3();
        system.out.println("流程结束");
    }

3.是自己的就是自己的

当一个方法放在本类和其他类中都可以的时候，那么，如果，一个方法放在本类中，不会增加类之间的耦合度，也不会造成不良影响，放在本类中。

4.慎用serializable

举例来说，在一个项目中使用rmi方式传递一个vo对象时，这个对象就必须实现serializable接口，也就是进行序列化。当你突然将客户端这个vo对象的访问权限从private更改为public的时候，而服务端没有进行对应的改变，就会出现错误。

4.迪米特原则的注意事项和细节

1.迪米特原则的核心就是降低类之间的耦合。只有耦合降低了，类的复用率才能提高。

2.注意事项：

凡事讲究适度，迪米特原则要求降低类之间的耦合，并不是要求没有耦合。