迪米特原則定義 迪米特原則，也叫最少知道原則，即一個類應該 對自己依賴的類知道的越少越好 ，而你被依賴的類多麼複雜，對我都沒有關係。也就是說，對於別依賴的類來說，不管業務邏輯多麼複雜，都應該儘量封裝在類的內部；對外除了必備的public方法，不再泄露任何信息。 1.問題由來 我們知道，類和類是有耦合 ...
迪米特原則定義
迪米特原則，也叫最少知道原則，即一個類應該對自己依賴的類知道的越少越好，而你被依賴的類多麼複雜，對我都沒有關係。也就是說，對於別依賴的類來說，不管業務邏輯多麼複雜，都應該儘量封裝在類的內部；對外除了必備的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.註意事項：
凡事講究適度，迪米特原則要求降低類之間的耦合，並不是要求沒有耦合。
