// 朋友的朋友：银行卡
class Card {
    private double balance = 1000.0;

    public double getBalance() {
        return balance;
    }

    public void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
            System.out.println("成功取款: " + amount + "，剩余余额: " + balance);
        } else {
            System.out.println("余额不足！");
        }
    }
}

// 直接朋友：顾客
class Customer {
    // Customer 拥有一个 Card，这是它的内部细节
    private Card card = new Card();

    public Card getCard() {
        return card;
    }
}

// 调用者：收银员
class Cashier {
    // 这个方法违反了迪米特法则
    public void charge(Customer customer, double amount) {
        // 1. 从 customer 获取 card (获取朋友的朋友)
        Card card = customer.getCard(); 
        
        // 2. 直接操作这个“陌生人”对象
        if (card.getBalance() >= amount) {
            card.withdraw(amount);
            System.out.println("收银员成功收款: " + amount);
        } else {
            System.out.println("收银员发现顾客余额不足，收款失败。");
        }
    }
}

问题分析：

代码是“火车失事”风格的： customer.getCard().withdraw(amount)（虽然这里分了两步写，但本质是一样的）。
高耦合： Cashier 类不仅依赖于 Customer 类，还依赖于 Card 类。它知道了 Customer 是通过 Card 来付款的。
破坏封装： Customer 的内部支付方式（用卡支付）被暴露给了 Cashier。
可维护性差： 如果未来 Customer 的支付方式变了，比如增加了微信支付 WeChatPay，那么 Cashier 类的 charge 方法就必须被修改！它需要增加逻辑来判断顾客到底是用卡还是用微信支付，这违反了开闭原则。

2. 遵循LoD的重构 (好的设计)

我们应该让 Customer 自己处理自己的事情（如何付款），Cashier 只需要告诉 Customer “请付钱”即可。

第1步：在“直接朋友”类中封装行为

在 Customer 类中添加一个 pay 方法，把与 Card 的交互封装在内部。

// 银行卡类保持不变
class Card {
    // ... (同上)
}

// 直接朋友：顾客
class Customer {
    private Card card = new Card();
    // 也可以有其他支付方式，比如 private WeChatPay wechatPay;

    // 关键！提供一个高层服务，隐藏内部实现
    public boolean pay(double amount) {
        // Customer 自己和自己的“直接朋友”（card）打交道
        if (card.getBalance() >= amount) {
            card.withdraw(amount);
            return true; // 支付成功
        }
        return false; // 支付失败
    }
}

// 调用者：收银员
class Cashier {
    // 这个方法现在遵循了迪米特法则
    public void charge(Customer customer, double amount) {
        // 只和“直接朋友”Customer 交互，告诉它做事
        boolean success = customer.pay(amount);
        
        if (success) {
            System.out.println("收银员成功收款: " + amount);
        } else {
            System.out.println("收银员被告知支付失败。");
        }
    }
}

优势分析：

低耦合： Cashier 现在只依赖于 Customer，它完全不知道 Card 的存在。
强封装： Customer 如何付款是它自己的秘密。Cashier 只关心支付的结果（成功或失败）。
高可维护性和扩展性： 如果 Customer 以后想用微信支付，只需要修改 Customer 类内部的 pay 方法即可，Cashier 类完全不需要任何改动。

// 比如，Customer 类可以这样修改，而 Cashier 不受影响
class Customer {
    private Card card = new Card();
    private WeChatPay wechatPay = new WeChatPay();
    
    public boolean pay(double amount) {
        // 可以在内部自己决定用哪种方式支付
        if (wechatPay.isAvailable()) {
            return wechatPay.processPayment(amount);
        } else {
            // ... 用卡支付的逻辑 ...
        }
    }
}

总结

	违反 LoD 的设计	遵循 LoD 的设计
核心思想	我要深入了解你，然后自己动手。	我不关心你怎么做，你把事给我办好就行。
代码特征	`a.getB().getC().doSomething()`	`a.doSomething()`
耦合关系	调用者与多个类（朋友、朋友的朋友）耦合	调用者只与直接朋友耦合
封装性	差，内部实现细节暴露	好，内部实现被隐藏
维护性	差，一个内部改动可能引发连锁反应	好，改动被限制在单个类内部

迪米特法则是一个旨在降低类之间耦合度的指导原则。通过让每个对象只与它的“直接朋友”通信，我们可以创建出更加独立、健壮和易于维护的模块，这使得整个软件系统更加灵活和稳定。