这段代码如何违反了德米特法则？

Question

以下代码违反了德墨忒尔定律：

public class Student extends Person {
  private Grades grades;

  public Student() {
  }

  /** Must never return null; throw an appropriately named exception, instead. */
  private synchronized Grades getGrades() throws GradesException {
    if( this.grades == null ) {
      this.grades = createGrades();
    }

    return this.grades;
  }

  /** Create a new instance of grades for this student. */
  protected Grades createGrades() throws GradesException {
    // Reads the grades from the database, if needed.
    //
    return new Grades();
  }

  /** Answers if this student was graded by a teacher with the given name. */
  public boolean isTeacher( int year, String name ) throws GradesException, TeacherException {
    // The method only knows about Teacher instances.
    //
    return getTeacher( year ).nameEquals( name );
  }

  private Grades getGradesForYear( int year ) throws GradesException {
    // The method only knows about Grades instances.
    //
    return getGrades().getForYear( year );
  }

  private Teacher getTeacher( int year ) throws GradesException, TeacherException {
    // This method knows about Grades and Teacher instances. A mistake?
    //
    return getGradesForYear( year ).getTeacher();
  }
}

public class Teacher extends Person {
  public Teacher() {
  }

  /**
   * This method will take into consideration first name,
   * last name, middle initial, case sensitivity, and
   * eventually it could answer true to wild cards and
   * regular expressions.
   */
  public boolean nameEquals( String name ) {
    return getName().equalsIgnoreCase( name );
  }

  /** Never returns null. */
  private synchronized String getName() {
    if( this.name == null ) {
      this.name == "";
    }

    return this.name;
  }
}

问题

1. LoD坏了？
2. 破坏 LoD 的代码在哪里？
3. 应该如何编写代码来维护 LoD？

Answer 1

我认为这里有两个问题：

1. Grades 逻辑与 Student 混合太多。它应该在 Grades 类中完成，
2. Teacher 的逻辑被放置在 Student 中。

结论：学生对教师和成绩的内部结构和逻辑了解太多，从而破坏了 LoD

Answer 2

诸如此类的大多数问题都可以通过重新访问域模型来解决。

看起来学生的责任比应有的要多得多。它应该只有一个改变的理由。

我将通过添加 ReportCard 对象来重构它。

public class ReportCard
{
  public Student Student...
  public int Year...
  public ReportCardItem[] ReportCardItems...

  getGrades()...
  createGrades()...
}

public class ReportCardItem
{
  public Grade Grade...
  public string Subject...
  public Teacher Teacher...
}

Answer 3

Student 类中的方法违反了 Demeter 定律，

private Grades getGradesForYear( int year )
private Teacher getTeacher( int year )

因为这些方法向应用程序公开了域对象 Grades 和 Teacher。

假设您希望继续隐藏学生中的成绩和成绩中的教师，解决此问题的一种方法是在学生类中定义代理方法（也称为委托方法），代表内部成绩和教师对象进行操作应用程序的，类似于方法 Student.isTeacher(int, String)。此解决方案可能会导致学生中的“成绩”和“教师”中的方法重复，这是一个缺点尊重 LofD 的类设计。

更好的解决方案是从学生中删除成绩和教师，并将它们全部放在另一个班级中，成绩单说：

class Transcript {
  Student student;
  Teacher teacher;
  Grades grades;
  Integer year;
}  

Answer 4

根据您提到的维基百科文章，Person.isTeacher“到达”。

我惊讶地发现成绩列表是学生的财产。难道这不应该是学校了解和管理的事情吗？我会问学校，哪位老师哪一年给学生评分...

Answer 5

通过拥有这两个私有函数会破坏 LoD。

private Grades getGradesForYear( int year )
private Teacher getTeacher( int year )

学生不应该需要逻辑来执行此类任务。

我重新设计的方法是将数据与逻辑分开。学生应该纯粹是一个数据而已。它应仅包含有关学生和学生的信息。因此，这不包括成绩，因为该概念需要其他概念，例如科目和教师。

对于老师来说也是如此。然后，我将创建一个存储成绩信息的位置和另一个存储科目信息的位置。

要执行类似的任务，我会这样做：

gradesDatabase.getGrade(subject, student);
subjectDatabase.getTeacher(subject, student);

其中主体也是一个仅数据的对象。