0108_迪米特法则

定义：也称最少知道原则，一个对象应该对其他对象有最少的了解

场景

还以人类为例，人类属性有姓名和年龄。另一个对象需要使用这两个属性。这里通过一个反例和一个正例来进行说明。

反例

InvalidHuman类

• 职责：表示一个人的基本信息

public class InvalidHuman{

    // 姓名
    public String name;
    // 年龄
    public int age;

}

InvalidHumanManager类

• 职责：违反迪米特法则的实现，直接访问对象的内部结构

public class InvalidHumanManager {
    // 人类列表，用于存储多个人类对象
    private List<InvalidHuman> humans;
    
    // 构造函数，初始化人类列表
    public InvalidHumanManager() {
        this.humans = new ArrayList<>();
    }
    
    // 添加人类对象到列表中
    public void addHuman(InvalidHuman human) {
        humans.add(human);
    }
    
    // 违反迪米特法则：直接访问对象的内部结构
    // 该方法直接访问了InvalidHuman对象的公共字段，而不是通过方法来获取信息
    public void printHumanInfo(int index) {
        // 直接访问human的字段，违反了封装性
        // 正确的做法应该是让InvalidHuman类提供获取信息的方法
        System.out.println("姓名：" + humans.get(index).name + "，年龄：" + humans.get(index).age);
    }
}

违反了封装原则，增加了类之间的耦合；当 InvalidHuman 的内部结构改变时，InvalidHumanManager 也需要修改。

正例

Human类

• 职责：人类实体类，包含年龄和姓名属性

public class Human {
    // 年龄属性
    private int age;
    // 姓名属性
    private String name;
    
    public Human(String name, int age) {
        this.name = name;
        this.age = age;
    }
    /**
     * 获取人类信息
     * @return 包含姓名和年龄的字符串信息
     */
    public String getInfo() {
        return "姓名：" + this.name + "，年龄：" + this.age;
    }
}

HumanManager类

• 职责：遵循迪米特法则的实现，只与直接朋友通信，不与陌生人交互

public class HumanManager {
    // 人类列表，用于存储人类对象
    private List<Human> humans;
    
    // 构造函数，初始化人类列表
    public HumanManager() {
        this.humans = new ArrayList<>();
    }

    // 添加人类对象到列表中
    public void addHuman(Human human) {
        humans.add(human);
    }
    
    // 遵循迪米特法则：只与直接朋友通信
    // 打印指定索引位置的人类信息
    public void printHumanInfo(int index) {
        System.out.println(humans.get(index).getInfo());
    }    
}

DemeterPrincipleDemo类

• 职责：迪米特法则的反例和正例的演示类

public class DemeterPrincipleDemo {
    public static void main(String[] args) {
        // 创建违反迪米特法则的示例
        System.out.println("=== 违反迪米特法则的例子 ===");
        // 直接访问公共字段，违反了封装性原则
        InvalidHuman invalidHuman = new InvalidHuman();
        invalidHuman.name = "张三";
        invalidHuman.age = 25;
        
        // 管理器直接访问对象的内部字段，违反了迪米特法则
        InvalidHumanManager invalidManager = new InvalidHumanManager();
        invalidManager.addHuman(invalidHuman);
        invalidManager.printHumanInfo(0); // 直接访问了InvalidHuman的公共字段
        
        // 创建遵循迪米特法则的示例
        System.out.println("\n=== 遵循迪米特法则的例子 ===");
        // 通过构造函数初始化对象，保证了封装性
        Human human = new Human("李四", 30);
        // 管理器只与直接朋友通信，不直接访问对象内部结构
        HumanManager manager = new HumanManager();
        manager.addHuman(human);
        // 通过对象提供的方法获取信息，遵循迪米特法则
        manager.printHumanInfo(0);
    }
}

总结

• HumanManager 只与 Human 类交互，不关心其内部实现
• Human 类封装了自己的数据和行为，符合面向对象设计原则
• 降低了类之间的依赖，提高了系统的可维护性和扩展性

遵循迪米特法则可以使系统更加模块化，减少类之间的依赖关系，从而提高代码的可维护性和可扩展性。