Java 中常见的代码味道以及如何修复它们

代码异味表明 Java 代码中存在潜在问题，影响可维护性、可读性和性能。 虽然错误并不总是存在，但解决它们可以使您的代码库保持干净和高效。本文研究了五种常见的 Java 代码异味，提供了示例、解释和改进的解决方案。

---

1. 过长的方法

问题：过长的方法会妨碍可读性、测试和维护。即使使用辅助方法，组合多个抽象级别也会违反单一职责原则 (SRP)。

示例：

public void processOrder(Order order) {
    validateOrder(order);
    calculateDiscount(order);
    updateInventory(order);
    generateInvoice(order);
    sendNotification(order);
}

processOrder 混合了不相关的任务（验证、折扣计算、库存更新、发票和通知），因此很难在不产生意外后果的情况下进行修改。

解决方案：重构为更小、更集中的方法。命令模式或管道模式等设计模式增强了模块化性。

重构代码（命令模式）：

interface OrderCommand { void execute(Order order); }

class ValidateOrderCommand implements OrderCommand {
    public void execute(Order order) { /* Validation logic */ }
}

// ... other commands (ApplyDiscountCommand, etc.)

class OrderProcessor {
    List<OrderCommand> commands;

    public OrderProcessor(List<OrderCommand> commands) { this.commands = commands; }

    public void processOrder(Order order) {
        for (OrderCommand command : commands) { command.execute(order); }
    }
}

// Usage
List<OrderCommand> commands = List.of(new ValidateOrderCommand(), new ApplyDiscountCommand(), ...);
OrderProcessor processor = new OrderProcessor(commands);
processor.processOrder(new Order());

优点：改进的模块化、独立测试和命令重用、轻松添加新步骤。

---

2. 神课

问题：一个“神类”承担太多职责，导致耦合度高，可维护性差。

示例：

public class OrderManager {
    public void createOrder() { /* Implementation */ }
    public void updateOrder() { /* Implementation */ }
    public void deleteOrder() { /* Implementation */ }
    public void validatePayment() { /* Implementation */ }
    public void sendInvoice() { /* Implementation */ }
}

解决方案：将职责分解为更小的、更集中的类。

重构代码：

public class OrderService {
    public void createOrder() { /* Implementation */ }
    // ... other order-related methods
}

public class PaymentService {
    public void validatePayment() { /* Implementation */ }
}

public class NotificationService {
    public void sendInvoice() { /* Implementation */ }
}

好处：减少耦合，提高模块化，更容易维护、测试和独立扩展。

---

3. 神奇数字

问题：直接使用文字数字会降低代码清晰度并增加修改风险。

示例：

public double calculateDiscount(double totalAmount) {
    return totalAmount > 1000 ? totalAmount * 0.1 : totalAmount;
}

解决方案：用命名常量替换文字数字。

重构代码：

private static final double DISCOUNT_THRESHOLD = 1000;
private static final double DISCOUNT_RATE = 0.1;

public double calculateDiscount(double totalAmount) {
    return totalAmount > DISCOUNT_THRESHOLD ? totalAmount * DISCOUNT_RATE : totalAmount;
}

好处：增强可读性，降低更新过程中的错误风险，更清晰的业务逻辑。

---

4. 重复代码

问题：跨方法或类的重复代码会导致不一致和维护麻烦。

示例：

public double calculateTax(double amount) { return amount * 0.18; }
public double calculateDiscount(double amount) { return amount * 0.1; }

解决方案：将通用逻辑抽象为可重用的方法。

重构代码：

private double applyRate(double amount, double rate) { return amount * rate; }

public double calculateTax(double amount) { return applyRate(amount, 0.18); }
public double calculateDiscount(double amount) { return applyRate(amount, 0.1); }

好处：消除冗余，确保一致性，简化修改和扩展。

---

5. 参数列表过多

问题：具有许多参数的方法难以阅读、理解，并且在调用过程中容易出错。

示例：

public void processOrder(Order order) {
    validateOrder(order);
    calculateDiscount(order);
    updateInventory(order);
    generateInvoice(order);
    sendNotification(order);
}

解决方案：将参数封装在对象内或使用构建器模式。

重构代码：

interface OrderCommand { void execute(Order order); }

class ValidateOrderCommand implements OrderCommand {
    public void execute(Order order) { /* Validation logic */ }
}

// ... other commands (ApplyDiscountCommand, etc.)

class OrderProcessor {
    List<OrderCommand> commands;

    public OrderProcessor(List<OrderCommand> commands) { this.commands = commands; }

    public void processOrder(Order order) {
        for (OrderCommand command : commands) { command.execute(order); }
    }
}

// Usage
List<OrderCommand> commands = List.of(new ValidateOrderCommand(), new ApplyDiscountCommand(), ...);
OrderProcessor processor = new OrderProcessor(commands);
processor.processOrder(new Order());

好处：提高可读性和可扩展性；添加参数不需要更改方法签名。

---

主动解决代码异味可以防止更大的设计问题并减少技术债务，从而产生更健壮且可维护的 Java 应用程序。 记住 DRY（不要重复自己）和 SRP（单一职责原则）的原则，以获得更干净、更高效的代码。

以上是Java 中常见的代码味道以及如何修复它们的详细内容。更多信息请关注PHP中文网其他相关文章！