5、迪米特法则(Law of Demeter)

concept

1. Each unit should have only limited knowledge about other units: only units “closely” related to the current unit.
   每个单元对于其他的单元只能拥有有限的知识：只是与当前单元紧密联系的单元

2. Each unit should only talk to its friends; don’t talk to strangers.
   每个单元只能和它的朋友交谈：不能和陌生单元交谈

3. Only talk to your immediate friends.
   只与直接的朋友通信

---

analyse

• 【从依赖者的角度来说，只依赖应该依赖的对象。】
  【从被依赖者的角度说，只暴露应该暴露的方法。】
• 一个对象应当对其他对象保持最少的了解：通俗的来讲，一个类对自己依赖的类知道的越少越好。也就是说对于被依赖的类来讲，无论是多么复杂的逻辑，都尽量的讲逻辑封装在类的内部，对外只提供 public 方法，不对外泄露任何信息
• 只与直接的朋友通信：类中的【出现在 成员变量、方法参数、方法返回值中的类】为直接的朋友，而出现在局部变量中的类则不是直接的朋友。也就是说，陌生的类最好不要作为局部变量的形式出现在类的内部。
• 一个模块设计的好坏的一个重要标志就是该模块在多大程度上讲自己的内部数据与实现的有关细节隐藏起来。
• 一个类应该对自己需要耦合或调用的类知道得最少，它的内部是如何复杂都和自己没关系，只需知道它提供的public方法，其他的一概不关心。

---

example

有一个集团公司，下属单位有分公司和直属部门，现在要求打印出所有下属单位的员工ID。

/**
 * 分公司员工
 */
class SubEmployee {
    private String id;
    public void setId(String id) { this.id = id; }
    public String getId() { return id; }
}

/**
 * 分公司
 */
class SubCompanyManager {
    List<SubEmployee> getAllSubCompanyEmployee() {
        //业务【查询分公司所有员工信息】
        List<SubEmployee> employeeList = subEmployeeDao.listEmployees();
        return employeeList;
    }

}

/**
 * 总公司员工
 */
class Employee {
    private String id;
    public void setId(String id) { this.id = id; }
    public String getId() { return id; }
}

/**
 * 总公司
 */
class CompanyManager {
    SubCompanyManager subCompanyManager;
    public SubCompanyManager getSubCompanyManager() { return subCompanyManager;}
    public void setSubCompanyManager(SubCompanyManager subCompanyManager) {this.subCompanyManager = subCompanyManager;}
    
    public List<Employee> getAllCompanyEmployee() {
        //业务【查询总公司所有员工信息】
        List<Employee> employeeList = employeeDao.listEmployees();
    }
    
    //打印所有员工信息
    public void printAllEmployee() {
        List<Employee> companyEmployeeList = getAllCompanyEmployee();
        List<SubEmployee> subCompanyEmployeeList = this.subCompanyManager.getAllSubCompanyEmployee();
        for (Employee employee : companyEmployeeList) {
            System.out.println(employee.getId());
        }
        for (SubEmployee subEmployee : subCompanyEmployeeList) {
            System.out.println(subEmployee.getId());
        }
        System.out.println();
    }
}

public class Client{
    public static void main(String[] args) {
        CompanyManager companyManager=new CompanyManager();
        companyManager.setSubCompanyManager(new SubCompanyManager());
        companyManager.printAllEmployee();
    }
}

上述代码，已经初步实现了功能，根据 【迪米特法则】中提到的 “只与朋友通信”，发现 CompanyManager类中的 printAllEmployee方法中的 SubEmployee并不是CompanyManager的朋友【以局部变量出现的耦合不属于直接朋友】。从逻辑上讲总公司只与他的分公司以及总公司员工耦合就行了，与分公司的员工并没有任何联系，这样设计显然是增加了不必要的耦合。按照迪米特法则，应该避免类中出现这样非直接朋友关系的耦合。所以对CompanyManager以及SubCompanyManager进行优化

class SubCompanyManager {
    List<SubEmployee> getAllSubCompanyEmployee() {
        List<SubEmployee> employeeList = new ArrayList<>();
        // ubEmployeeDao.listEmployees();
        return employeeList;
    }
    //增加打印员工的方法
    public void printAllSubEmployee() {
        List<SubEmployee> subCompanyEmployeeList = getAllSubCompanyEmployee();
        for (SubEmployee subEmployee : subCompanyEmployeeList) {
            System.out.println(subEmployee.getId());
        }
    }
}

class CompanyManager {
    SubCompanyManager subCompanyManager;
    
    public SubCompanyManager getSubCompanyManager() {return subCompanyManager;}
    public void setSubCompanyManager(SubCompanyManager subCompanyManager) {  this.subCompanyManager = subCompanyManager; }
    
    public List<Employee> getAllCompanyEmployee() {
        List<Employee> employeeList = new ArrayList<>();
       employeeDao.listEmployees();
        return employeeList;
    }
    public void printAllEmployee() {
        List<Employee> companyEmployeeList = getAllCompanyEmployee();
        for (Employee employee : companyEmployeeList) {
            System.out.println(employee.getId());
        }
        //分公司调用打印员工的方法
        subCompanyManager.printAllSubEmployee();
    }
}

迪米特法则的核心观念就是类间解耦，降低类之间的耦合程度，只有弱耦合了以后，类的复用率才可以提高，由于每个类尽量减少对其他类的依赖，因此，很容易使得系统的功能模块功能独立，使得模块相互间存在尽
可能少的依赖关系。所以，在运用迪米特法则时要注意以下 6 点。

1. 在类的划分上，应该创建弱耦合的类。类与类之间的耦合越弱，就越有利于实现可复用的目标。
2. 在类的结构设计上，尽量降低类成员的访问权限。
3. 在类的设计上，优先考虑将一个类设置成不变类。
4. 在对其他类的引用上，将引用其他对象的次数降到最低。
5. 不暴露类的属性成员，而应该提供相应的访问器（set 和 get 方法）。
6. 谨慎使用序列化（Serializable）功能。

过分的使用迪米特原则，会产生大量这样的中介和传递类，类之间需要通信就通过第三方转发的方式，就会造成系统的不同模块之间的通信效率降低、使系统的不同模块之间不容易协调等缺点，同时大大增加了系统的复杂度。所以在釆用迪米特法则时需要反复权衡，确保高内聚和低耦合的同时，保证系统的结构清晰