迪米特法则

1. 基本介绍

1. 迪米特法则又叫最少知道原则，即一个类对自己所依赖的类知道的越少越好。换句话说，被依赖的类无论多么复杂，都应该将逻辑封装在自身类的内部；除了对外提供public接口，不对外泄露任何信息。

2. 简单点说一个对象应该对其他对象保持最少的了解。

3. 迪米特法则更简单的定义：只与直接的朋友通信；

4. 直接的朋友：只要两个对象之间有耦合关系就说这两个对象之间是直接朋友关系。耦合的方式有很多种：依赖、关联、组合、聚合… 例如：成员变量、方法参数、方法返回值中的类。

5. 非直接的朋友：出现在局部变量中的类不是直接的朋友，陌生的类最好不要以局部变量的形式出现在类的内部。

2. 案例分析

2.1、案例1

现在划分三个类：

• 学生类：有一个学号，对应的get、set方法。

• 学生管理类：获得学生信息的一个方法。

• 教师类：有一个教工号，对应的get、set方法。

• 教师管理类：获得教师信息的一个方法。

• 学校类：获取学生、教师信息。

分析：

1. Student、Teacher类都一样是非常基础的类设计

2. StudentManager、TeacherManager类同样比较基础。

3. School类虽然只有一个方法，getAllInfo方法中只有两个直接的朋友：TeacherManager、StudentManager。而方法内部（局部变量）出现了：Student类、Teacher类。这并不是直接朋友，违背了迪米特原则。

4. 很显然getAllInfo中获得了学生、老师的信息；并且进行了信息的输出。这些逻辑代码不应该出现在getAllInfo中，而是应该在它们自身对应的类中。

2.2、案例2（改进）

现在将打印学生信息、教师信息的逻辑代码分别各自提到TeacherManager、StudentManager类中；

TeacherManager类中有直接朋友Teacher类，StudentManager类中也有直接的朋友Student。

import java.util.ArrayList;
import java.util.List;

class Teacher{
    private int id;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
}
class Student{
    private int id;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
}

class TeacherManager{

    public List<Teacher> TeacherInfo(){
        List<Teacher> list = new ArrayList<>();
        for(int i = 0;i < 5;i++){
            Teacher t = new Teacher();
            t.setId(i);
            list.add(t);
        }
        return list;
    }
    public void printTeacher(){
        List<Teacher> teachers = TeacherInfo();
        for (Teacher t : teachers) {
            System.out.println("教师: " + t.getId());
        }
    }
}

class StudentManager{
    public List<Student> StudentInfo(){
        List<Student> list = new ArrayList<>();
        for(int i = 0;i < 5;i++){
            Student s = new Student();
            s.setId(i);
            list.add(s);
        }
        return list;
    }
    public void printStudent(){
        List<Student> students = StudentInfo();
        for (Student s : students) {
            System.out.println("学生: " + s.getId());
        }
    }
}

class School{

    public void getAllInfo(TeacherManager teacherManager, StudentManager studentManager){
        teacherManager.printTeacher();
        System.out.println("==============================");
        studentManager.printStudent();
    }
}

public class Demeter02 {
    public static void main(String[] args) {
        School school = new School();
        school.getAllInfo(new TeacherManager(), new StudentManager());
    }
}

3. 总结

迪米特法则的核心是降低类之间的耦合度，由于每个类都减少了不必要的依赖，因此迪米特法则也只是降低类之间的耦合度，并不是完全没有耦合。