①一個對象應該對其他對象保持最少的了解

②類與類關系越密切，耦合度越大

③迪米特法則又叫最少知道原則，即一個類對自己依賴的類知道的越少越好（對于一類被依賴的類，不管是多么復雜，對外只提供方法即可，不去展現內部的具體實現）

④簡單的定義就是：只與直接的朋友通信

直接的朋友：每個對象都會與其他的對象有耦合關系，只有兩個對象只有有耦合關系我們就稱這兩個對象為朋友關系。耦合的方式很多，依賴、關聯、組合、聚合等，其中，我們稱出現的成員變量，方法參數，方法返回值中的類為直接朋友，而出現在局部變量中的類就不是直接的朋友。也就是說陌生的類，最好不要以局部變量的形式出現在類的內部?

?

先看一段代碼

1 import java.util.ArrayList; 2 import java.util.List; 3 4 //客戶端 5 public class Demeter1 { 6 7 public static void main(String[] args) { 8 //創建了一個 SchoolManager 對象 9 SchoolManager schoolManager = new SchoolManager(); 10 //輸出學院的員工id 和 學校總部的員工信息 11 schoolManager.printAllEmployee(new CollegeManager()); 12 13 } 14 15 } 16 17 18 //學校總部員工類 19 class Employee { 20 private String id; 21 22 public void setId(String id) { 23 this.id = id; 24 } 25 26 public String getId() { 27 return id; 28 } 29 } 30 31 32 //學院的員工類 33 class CollegeEmployee { 34 private String id; 35 36 public void setId(String id) { 37 this.id = id; 38 } 39 40 public String getId() { 41 return id; 42 } 43 } 44 45 46 //管理學院員工的管理類 47 class CollegeManager { 48 //返回學院的所有員工 49 public List<CollegeEmployee> getAllEmployee() { 50 List<CollegeEmployee> list = new ArrayList<CollegeEmployee>(); 51 for (int i = 0; i < 10; i++) { //這里我們增加了10個員工到 list 52 CollegeEmployee emp = new CollegeEmployee(); 53 emp.setId("學院員工id= " + i); 54 list.add(emp); 55 } 56 return list; 57 } 58 } 59 60 //學校管理類 61 62 //分析 SchoolManager 類的直接朋友類有哪些 Employee、CollegeManager 63 //CollegeEmployee 不是 直接朋友 而是一個陌生類，這樣違背了 迪米特法則 64 class SchoolManager { 65 //返回學校總部的員工 66 public List<Employee> getAllEmployee() { 67 List<Employee> list = new ArrayList<Employee>(); 68 69 for (int i = 0; i < 5; i++) { //這里我們增加了5個員工到 list 70 Employee emp = new Employee(); 71 emp.setId("學校總部員工id= " + i); 72 list.add(emp); 73 } 74 return list; 75 } 76 77 //該方法完成輸出學校總部和學院員工信息(id) 78 void printAllEmployee(CollegeManager sub) { 79 80 //分析問題 81 //1. 這里的 CollegeEmployee 不是 SchoolManager的直接朋友 82 //2. CollegeEmployee 是以局部變量方式出現在 SchoolManager 83 //3. 違反了 迪米特法則 84 85 //獲取到學院員工 86 List<CollegeEmployee> list1 = sub.getAllEmployee(); 87 System.out.println("------------學院員工------------"); 88 for (CollegeEmployee e : list1) { 89 System.out.println(e.getId()); 90 } 91 //獲取到學校總部員工 92 List<Employee> list2 = this.getAllEmployee(); 93 System.out.println("------------學校總部員工------------"); 94 for (Employee e : list2) { 95 System.out.println(e.getId()); 96 } 97 } 98 }

以上代碼注釋的很清楚，這邊不需要再次解釋了：強調一點：陌生的類，最好不要以局部變量的形式出現在類的內部；陌生的類，最好不要以局部變量的形式出現在類的內部；陌生的類，最好不要以局部變量的形式出現在類的內部

改善后

?

1 import java.util.ArrayList; 2 import java.util.List; 3 4 //客戶端 5 public class Demeter1 { 6 7 public static void main(String[] args) { 8 System.out.println("~~~使用迪米特法則的改進~~~"); 9 //創建了一個 SchoolManager 對象 10 SchoolManager schoolManager = new SchoolManager(); 11 //輸出學院的員工id 和 學校總部的員工信息 12 schoolManager.printAllEmployee(new CollegeManager()); 13 14 } 15 16 } 17 18 19 //學校總部員工類 20 class Employee { 21 private String id; 22 23 public void setId(String id) { 24 this.id = id; 25 } 26 27 public String getId() { 28 return id; 29 } 30 } 31 32 33 //學院的員工類 34 class CollegeEmployee { 35 private String id; 36 37 public void setId(String id) { 38 this.id = id; 39 } 40 41 public String getId() { 42 return id; 43 } 44 } 45 46 47 //管理學院員工的管理類 48 class CollegeManager { 49 //返回學院的所有員工 50 public List<CollegeEmployee> getAllEmployee() { 51 List<CollegeEmployee> list = new ArrayList<CollegeEmployee>(); 52 for (int i = 0; i < 10; i++) { //這里我們增加了10個員工到 list 53 CollegeEmployee emp = new CollegeEmployee(); 54 emp.setId("學院員工id= " + i); 55 list.add(emp); 56 } 57 return list; 58 } 59 60 //輸出學院員工的信息 61 public void printEmployee() { 62 //獲取到學院員工 63 List<CollegeEmployee> list1 = getAllEmployee(); 64 System.out.println("------------學院員工------------"); 65 for (CollegeEmployee e : list1) { 66 System.out.println(e.getId()); 67 } 68 } 69 } 70 71 //學校管理類 72 73 //分析 SchoolManager 類的直接朋友類有哪些 Employee、CollegeManager 74 //CollegeEmployee 不是 直接朋友 而是一個陌生類，這樣違背了 迪米特法則 75 class SchoolManager { 76 //返回學校總部的員工 77 public List<Employee> getAllEmployee() { 78 List<Employee> list = new ArrayList<Employee>(); 79 80 for (int i = 0; i < 5; i++) { //這里我們增加了5個員工到 list 81 Employee emp = new Employee(); 82 emp.setId("學校總部員工id= " + i); 83 list.add(emp); 84 } 85 return list; 86 } 87 88 //該方法完成輸出學校總部和學院員工信息(id) 89 void printAllEmployee(CollegeManager sub) { 90 91 //分析問題 92 //1. 將輸出學院的員工方法，封裝到CollegeManager 93 sub.printEmployee(); 94 95 //獲取到學校總部員工 96 List<Employee> list2 = this.getAllEmployee(); 97 System.out.println("------------學校總部員工------------"); 98 for (Employee e : list2) { 99 System.out.println(e.getId()); 100 } 101 } 102 }

?小結：迪米特法則的核心是降低類與類之間的耦合，但是并不是要求完全沒有依賴關系

轉載于:https://www.cnblogs.com/zyzblogs/p/11274446.html

總結

以上是生活随笔為你收集整理的设计模式系列之七大原则之——迪米特法则的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。