设计模式系列（二）设计模式原则——迪米特法则(Demeter Principle)

简介

• 一个对象应该对其他对象保持最少的了解

• 类与类关系越密切，耦合度越大

• 迪米特法则又叫最少知道原则，即一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部。对外除了提供的public方法，不对外泄露任何信息

• 迪米特法则还有个更简单的定义:只与直接的朋友通信——每个对象都会与其他对象由耦合关系，只要两个对象之间有耦合关系,我们就说这两个对象之间是朋友关系。耦合的方式很多，依赖，关联，组合，聚合等。其中，我们称出现成员变量，方法参数，方法返回值中的类为直接的朋友，而出现在局部变量中的类不是直接的朋友。也就是说，陌生的类最好不要以局部变量的形式出现在类的内部。

举例

学校下辖多个学院和总部，请给出学校总部和各学院员工的ID

// client，user
public class Demeter  {
    public static void main(String[] args) {
        Manager m = new Manager();
        m.printAllEmplyoee(new CollegeManager());
    }
}

// 总部员工
class Employee {
    private String id;
    
    String getter();
    void setter(String id);
}

// 学院员工
class CollegeEmployee {
    private String id;
    
    String getter();
    void setter(String id);
}

class CollegeManager {
    // 获得学院全部员工
    public List<CollegeEmployee> getCollegeEmployee() {
        List<CollegeEmployee> emps = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            CollegeEmployee emp = new CollegeEmployee();
            emp.setId("college employee:" + i);
            emps.add(emp);
        }
        return emps;
    }
}

// 迪米特分析
// Employee、CollegeManager是Manager类的“直接朋友”
// CollegeEmployee不是Manager类的“直接朋友”，是一个陌生类
class Manager {
    // 获得总部全部员工
    public List<Employee> getEmployee() {
        List<Employee> emps = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            Employee emp = new Employee();
            emp.setId("employee:" + i);
            emps.add(emp);
        }
        return emps;
    }
    
    public void printAllEmplyoee(CollegeManager cm) {
        for (CollegeEmployee cEmp : cm.getCollegeEmployee()) {
            print(cEmp.getId());
        }
        
        for (Employee emp : this.getEmployee()) {
            print(emp.getId());
        }
    }
}

根据迪米特法则改进：各类各司其职，完成各自的功能

// client，user
public class Demeter  {
    public static void main(String[] args) {
        Manager m = new Manager();
        m.printAllEmplyoee(new CollegeManager());
    }
}

// 总部员工
class Employee {
    private String id;
    
    String getter();
    void setter(String id);
}

// 学院员工
class CollegeEmployee {
    private String id;
    
    String getter();
    void setter(String id);
}

class CollegeManager {
    // 获得学院全部员工
    public List<CollegeEmployee> getCollegeEmployee() {
        List<CollegeEmployee> emps = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            CollegeEmployee emp = new CollegeEmployee();
            emp.setId("college employee:" + i);
            emps.add(emp);
        }
        return emps;
    }
    
    public void printAllEmplyoee() {
        for (CollegeEmployee cEmp : this.getCollegeEmployee()) {
            print(cEmp.getId());
        }
    }
}


class Manager {
    // 获得总部全部员工
    public List<Employee> getEmployee() {
        List<Employee> emps = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            Employee emp = new Employee();
            emp.setId("employee:" + i);
            emps.add(emp);
        }
        return emps;
    }
    
    public void printAllEmplyoee(CollegeManager cm) {
        cm.printAllEmployee(); // 将实现封装在“直接朋友”的类里
        
        for (Employee emp : this.getEmployee()) {
            print(emp.getId());
        }
    }
}

迪米特法则降低类之间的耦合，并不能也不可能消除类间的耦合

往期：

设计模式系列（一）概述_Jackie的博客-CSDN博客

设计模式系列（二）设计模式原则——单一职责原则_Jackie的博客-CSDN博客

设计模式系列（二）设计模式原则——接口隔离原则_Jackie的博客-CSDN博客

设计模式系列（二）设计模式原则——依赖倒转原则 (dependency inversion principle)_Jackie的博客-CSDN博客

​​​​​​设计模式系列（二）设计模式原则——里氏替换原则(Liskov Substitution Principle)_Jackie的博客-CSDN博客