迪米特原則定義

迪米特原則，也叫最少知道原則，即一個類應該對自己依賴的類知道的越少越好，而你被依賴的類多麼複雜，對我都沒有關係。也就是說，對於別依賴的類來說，不管業務邏輯多麼複雜，都應該儘量封裝在類的內部；對外除了必備的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 print
 
AllEmp(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.注意事項：

凡事講究適度，迪米特原則要求降低類之間的耦合，並不是要求沒有耦合。