模块的深度 = 功能 / 接口复杂度

深模块：
- 接口简单
- 功能强大
- 例：Unix 文件 I/O
  open(), read(), write(), close()
  4个方法，可以操作任何设备

浅模块：
- 接口复杂
- 功能有限
- 例：一个类有20个方法，每个方法只做一件简单的事

        功能
        ↑
   深   │  ████████
   模   │  ████████
   块   │  ████████
        │  ████████
        ├──────────→ 接口
   浅   │  ██
   模   │  ██
   块   │  ██

接口（Interface）：
- 模块对外暴露的部分
- 用户需要知道的
- 应该尽可能简单

实现（Implementation）：
- 模块内部的逻辑
- 用户不需要知道的
- 可以很复杂

好的设计：
- 简单的接口
- 复杂的实现
- 接口和实现之间有巨大的信息鸿沟

例：Java 的 HashMap
- 接口：put(), get(), remove(), size()
- 实现：哈希函数、冲突解决、动态扩容
- 用户不需要知道内部如何工作

每个模块应该在一个抽象层次上工作

不好的设计：
public void processOrder(Order order) {
    // 混合了不同抽象层次
    validateEmail(order.getEmail());    // 低层
    order.setStatus(CONFIRMED);          // 高层
    byte[] data = order.toBytes();       // 低层
    socket.write(data);                  // 低层
}

好的设计：
public void processOrder(Order order) {
    validate(order);         // 一个抽象层次
    confirm(order);          // 一个抽象层次
    ship(order);             // 一个抽象层次
}

// 低层细节在各自的方法中

Unix 的设计哲学：

1. 文件 I/O
   - 接口：open, read, write, close
   - 功能：操作任何设备（文件、管道、socket、终端）
   - 深度：极大

2. 进程管理
   - 接口：fork, exec, wait, exit
   - 功能：创建和管理任何进程
   - 深度：极大

3. 文本处理
   - 接口：管道 + 标准输入输出
   - 功能：组合任意文本处理工具
   - 深度：极大

Unix 的教训：
- 少量深模块 > 大量浅模块
- 简单的接口 + 强大的功能
- 模块可以组合使用

// 浅模块：接口复杂，功能有限
public class UserValidator {
    public boolean isValidEmail(String email) { ... }
    public boolean isValidName(String name) { ... }
    public boolean isValidAge(int age) { ... }
    public boolean isValidPhone(String phone) { ... }
    // 20 个验证方法...
}

// 深模块：接口简单，功能强大
public class Validator {
    // 一个方法，验证整个对象
    public ValidationResult validate(Object obj) {
        // 内部使用反射、注解等复杂机制
        // 用户不需要知道细节
    }
}

// 使用
ValidationResult result = validator.validate(user);
if (!result.isValid()) {
    result.getErrors().forEach(System.out::println);
}