十三、迭进（Evolution）🔥迭进（Evolution）这一章的核心是如何让代码像生物进化一样优雅迭代，而不是在

🔥迭进（Evolution）

这一章的核心是如何让代码像生物进化一样优雅迭代，而不是在修修补补中腐烂。以下硬核内容分成原则、实践、反模式三部分。

📜 迭进四定律（Kent Beck 原版 + 现代解读）

运行所有测试 → 确保代码不会在迭代中崩掉
消除重复 → 用「抽象」或「组合」干掉重复代码
表达意图 → 让下一个程序员（包括未来的你）秒懂
最少元素 → 类/方法/变量能删就删（YAGNI原则）

⚡️ 实战：如何用四定律重构一段垃圾代码

💩 Before（典型烂代码）

public class OrderProcessor {
    public void process(Order order) {
        // 1. 验证订单
        if (order.items == null || order.items.isEmpty()) {
            throw new IllegalArgumentException("No items!");
        }
        if (order.customer == null) {
            throw new IllegalArgumentException("No customer!");
        }

        // 2. 计算总价
        double total = 0;
        for (Item item : order.items) {
            total += item.price * item.quantity;
        }
        if (order.discount != null) {
            total -= order.discount.amount;
        }

        // 3. 扣库存
        for (Item item : order.items) {
            InventoryService.reduceStock(item.id, item.quantity);
        }

        // 4. 支付
        PaymentService.charge(order.customer, total);
    }
}

❌ 问题点：

方法太长，违反单一职责
业务逻辑和检查混在一起
直接调服务，无法模拟测试

🌟 After（四定律优化后）

// 定律1：运行所有测试 → 拆小块 + 依赖注入
public class OrderProcessor {
    private final InventoryService inventory;
    private final PaymentService payment;

    public OrderProcessor(InventoryService inventory, PaymentService payment) {
        this.inventory = inventory;
        this.payment = payment;
    }

    public void process(Order order) {
        validate(order);          // 验证
        double total = calculateTotal(order);  // 计算
        updateInventory(order);   // 扣库存
        makePayment(order, total); // 支付
    }

    // 定律2 & 3：消除重复 + 表达意图
    private void validate(Order order) {
        if (order.hasNoItems()) throw new IllegalArgumentException("No items!");
        if (order.hasNoCustomer()) throw new IllegalArgumentException("No customer!");
    }

    private double calculateTotal(Order order) {
        return order.items.stream()
                .mapToDouble(item -> item.price * item.quantity)
                .sum() - order.getDiscountAmount();
    }

    // ...其他方法类似
}

✅ 优化点：

测试友好：依赖可Mock，方法可单独测试
语义清晰：方法名即注释
去重复：计算逻辑复用stream
最少元素：无多余变量

💥 反模式：迭代的7大陷阱

陷阱	症状	解法
大泥球架构	类越改越大，无法拆分	强制「类 ≤ 500行」
虚假复用	为了复用而抽象，反而更难改	先重复3次再抽取
过早优化	"未来可能需要"的代码	先跑基准测试
参数膨胀	方法参数超过5个	封装成DTO/Builder模式
魔法数字	`if (status == 3)`	用枚举/常量替换
僵尸代码	没人敢删的注释代码	版本控制+定期清理
紧耦合	改A模块必须改B模块	事件驱动/中介者模式

🚀 现代优化技巧

1. 小步快跑：Git策略

# 每个commit只做一件事（利于回滚）
git commit -m "refactor(Order): extract validation logic"
git commit -m "feat(Payment): add retry mechanism"

2. CD/CI自动化规则

# GitHub Actions示例（每次提交自动检查）
- name: Run Tests
  run: mvn test

- name: Check Code Smells
  run: sonar-scanner  # 用SonarQube检测坏味道

3. 演进式API设计

// v1 API（旧版兼容）
app.get('/api/orders', (req, res) => {
  res.json(getLegacyOrders());
});

// v2 API（新版优化）
app.get('/api/v2/orders', (req, res) => {
  res.json(getOptimizedOrders());
});

📌 终极思维模型

好代码不是一次性设计出来的，而是像雕刻一样不断：

写出来（先让它能跑）
测起来（确保不会炸）
优化它（让后续改动更容易）
重复 ♻️