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 {
    @Override
    public void execute(Order order) {
        // validation logic
    }
}

class ApplyDiscountCommand implements OrderCommand {
    @Override
    public void execute(Order order) {
        // discount application logic
    }
}

class OrderProcessor {
    private List commands;

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

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

// 使用示例
List commands = List.of(
    new ValidateOrderCommand(),
    new ApplyDiscountCommand(),
    new UpdateInventoryCommand(),
    new GenerateInvoiceCommand(),
    new NotifyCustomerCommand()
);

OrderProcessor processor = new OrderProcessor(commands);
processor.processOrder(new Order());

优势：

• 提高了模块化程度。
• 每个命令都处理单一职责，并且可以独立测试或重用。
• 添加新步骤（例如欺诈检测）就像添加新的 OrderCommand 一样简单。

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 */ }
    public void updateOrder() { /* implementation */ }
    public void deleteOrder() { /* implementation */ }
}

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 createUser(String firstName, String lastName, String email, String phoneNumber, String address) {
    // implementation
}

改进方法：

将参数封装到对象中，或者使用构建器模式。

重构代码：

public class User {
    private String firstName;
    private String lastName;
    private String email;
    private String phoneNumber;
    private String address; // Getters, setters, and constructor
}

public void createUser(User user) {
    // Implementation
}

优势：

• 提高了可读性和可扩展性。
• 可以在不更改方法签名的情况下添加其他参数。

代码坏味道是更深层次设计问题的早期信号，这些问题可能会影响可维护性和可扩展性。通过识别和解决这些坏味道，可以提高代码质量，减少技术债务。

遵循 DRY（Don't Repeat Yourself）、SRP（单一职责原则）和模块化设计等原则，可以构建健壮、整洁且高效的 Java 应用程序。

您在项目中遇到过这些代码坏味道吗？欢迎在评论区分享您的经验和解决方案！

本篇关于《Java 中常见的代码味道以及如何修复它们》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于文章的相关知识，请关注golang学习网公众号！