迪米特法则

Java迪米特法则

迪米特法则（Law of Demeter，LoD），即最少知识原则（Least Knowledge Principle，LKP），是一种软件设计原则。它要求一个对象应该对其它对象有尽可能少的了解，通常也被称为“不和陌生人说话”。

这篇文章将为大家介绍Java迪米特法则的概念和实现方法。文章将包括以下内容：

• 迪米特法则的概念
• 迪米特法则的优点
• 迪米特法则的实现方法
  • 例子说明
  • 代码示例
• 总结

迪米特法则的概念

迪米特法则是一种软件设计原则，旨在降低耦合性，提高模块的复用性和可维护性。它要求一个对象应该尽量少地去了解其它对象。具体来说，一个对象不应该直接与其它对象交互，而是应该通过一个中间对象来进行交互。这样可以避免对象之间的直接耦合，提高系统的可扩展性和可维护性。

迪米特法则的优点

• 降低耦合性：由于对象之间的交互通过中间对象进行，可以有效地降低对象之间的耦合程度。
• 提高模块的复用性：由于模块之间的耦合度降低，可以更方便地对模块进行复用。
• 提高系统的可维护性：由于模块之间的耦合度降低，系统的维护也会变得更加容易。

迪米特法则的实现方法

例子说明

假设我们有一个学生类（Student）和一个班级类（Classroom），每个学生都可以加入一个班级。在这个场景中，我们可以使用迪米特法则来降低Student和Classroom之间的耦合度。

代码示例

首先，我们创建一个班级类：

public class Classroom {

    private String name;
    private List<Student> students;

    public Classroom(String name) {
        this.name = name;
        this.students = new ArrayList<>();
    }

    public void addStudent(Student student) {
        students.add(student);
        System.out.println("Add student " + student.getName() + " to " + name + ".");
    }

    public void removeStudent(Student student) {
        students.remove(student);
        System.out.println("Remove student " + student.getName() + " from " + name + ".");
    }

    public List<Student> getStudents() {
        return Collections.unmodifiableList(students);
    }
}

然后，我们创建一个学生类：

public class Student {

    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void joinClassroom(Classroom classroom) {
        classroom.addStudent(this);
    }

    public void leaveClassroom(Classroom classroom) {
        classroom.removeStudent(this);
    }
}

可以看到，学生类中的joinClassroom方法和leaveClassroom方法都使用了班级类中的addStudent方法和removeStudent方法。这样会导致学生类和班级类之间的耦合度增加，不符合迪米特法则。

为了遵循迪米特法则，我们可以创建一个中间类（ClassroomService），来处理班级和学生之间的交互，如下所示：

public class ClassroomService {

    private Map<String, Classroom> classrooms;

    public ClassroomService() {
        classrooms = new HashMap<>();
    }

    public void addClassroom(String name) {
        Classroom classroom = new Classroom(name);
        classrooms.put(name, classroom);
        System.out.println("Add classroom " + name + ".");
    }

    public void removeClassroom(String name) {
        classrooms.remove(name);
        System.out.println("Remove classroom " + name + ".");
    }

    public void addStudentToClassroom(String classroomName, Student student) {
        Classroom classroom = classrooms.get(classroomName);
        classroom.addStudent(student);
    }

    public void removeStudentFromClassroom(String classroomName, Student student) {
        Classroom classroom = classrooms.get(classroomName);
        classroom.removeStudent(student);
    }

    public List<Student> getStudents(String classroomName) {
        Classroom classroom = classrooms.get(classroomName);
        return classroom.getStudents();
    }
}

中间类（ClassroomService）中包含了班级和学生之间的交互，学生类和班级类不再直接交互。我们可以通过以下代码来使用这个中间类：

public class Main {

    public static void main(String[] args) {
        ClassroomService classroomService = new ClassroomService();
        classroomService.addClassroom("Class A");

        Student student1 = new Student("Tom", 18);
        Student student2 = new Student("Jerry", 19);

        classroomService.addStudentToClassroom("Class A", student1);
        classroomService.addStudentToClassroom("Class A", student2);

        List<Student> students = classroomService.getStudents("Class A");
        for (Student student : students) {
            System.out.println(student.getName());
        }

        classroomService.removeStudentFromClassroom("Class A", student1);

        students = classroomService.getStudents("Class A");
        for (Student student : students) {
            System.out.println(student.getName());
        }
    }
}

在这个示例中，我们创建了一个ClassroomService对象，然后添加了一个班级。接着创建了两个学生对象，然后将它们添加到班级中。我们也可以获取班级中所有的学生列表。最后，我们从班级中删除了一个学生，并再次获取班级中的所有学生列表。使用这个中间类，我们就成功地遵循了迪米特法则，降低了模块之间的耦合度。

总结

迪米特法则要求一个对象尽量少地去了解其它对象，以降低模块之间的耦合度，提高系统的可扩展性和可维护性。使用迪米特法则可以帮助我们设计出更加健壮、灵活和可维护的系统。