分解条件表达式

• 提高代码的可读性。
• 使每个逻辑块的意图更清晰。
• 便于测试和维护。

消除代码谜题

避免使用复杂的布尔逻辑或嵌套条件，这些会让代码像谜题一样难以理解其真实意图。 重构前：

public boolean isEligibleForBonus(int yearsOfService, double salesAmount, boolean hasGoodPerformance, boolean isManager) {
// 这是一个复杂的布尔逻辑，需要仔细分析  
    return (yearsOfService > 5 && salesAmount > 100000) || (hasGoodPerformance && isManager);
}

重构后：

public boolean isEligibleForBonus(int yearsOfService, double salesAmount, boolean hasGoodPerformance, boolean
        isManager) {
    boolean meetsServiceAndSales = yearsOfService > 5 && salesAmount > 100000;
    boolean isHighPerformingManager = hasGoodPerformance && isManager;
    return meetsServiceAndSales || isHighPerformingManager;
}

// 进一步优化，使用方法提取来命名条件  
public boolean isEligibleForBonusFurtherOptimized(int yearsOfService, double salesAmount, boolean hasGoodPerformance,
                                                  boolean isManager) {
    return meetsServiceAndSales(yearsOfService, salesAmount) || isHighPerformingManager(hasGoodPerformance, isManager);
}

private boolean meetsServiceAndSales(int yearsOfService, double salesAmount) {
    return yearsOfService > 5 && salesAmount > 100000;
}

private boolean isHighPerformingManager(boolean hasGoodPerformance, boolean isManager) {
    return hasGoodPerformance && isManager;
}

减少认知负荷

通过使用卫语句（Guard Clauses）和策略模式等，减少代码阅读者在理解执行路径时需要跟踪的“分支”数量。

• 使方法的正常执行路径扁平化。
• 提前处理异常或特殊情况，然后返回。
• 提高代码的扫描性。 重构前（深度嵌套）：

public String processOrder(Order order) {
    if (order != null) {
        if (order.isValid()) {
            if (order.getTotalAmount() > 0) {
// 核心业务逻辑  
                return "Order processed successfully for " + order.getTotalAmount();
            } else {
                return "Order total amount must be positive.";
            }
        } else {
            return "Order is not valid.";
        }
    } else {
        return "Order cannot be null.";
    }
}

重构后（使用卫语句）：

public String processOrder(Order order) {
    if (order == null) {
        return "Order cannot be null."; // 卫语句  
    }
    if (!order.isValid()) {
        return "Order is not valid."; // 卫语句  
    }
    if (order.getTotalAmount() <= 0) {
        return "Order total amount must be positive."; // 卫语句  
    }

    // 核心业务逻辑，现在更清晰地位于方法的主体  
    return "Order processed successfully for " + order.getTotalAmount();
}


// 策略模式示例（用于替代复杂的 if-else if-else 链）  
// 假设根据订单类型有不同的处理方式  
interface OrderProcessor {
    String process(Order order);
}

class StandardOrderProcessor implements OrderProcessor {
    @Override
    public String process(Order order) {
        return "Standard order processed.";
    }
}

class PriorityOrderProcessor implements OrderProcessor {
    @Override
    public String process(Order order) {
        return "Priority order processed faster.";
    }
}

避免重复条件

相同的条件逻辑分散在代码的多个地方。

• 减少代码冗余。
• 确保逻辑修改时只需要在一个地方进行。
• 提高代码的可维护性。

重构前：

public void sendNotification(User user, String message) {
    if (user != null && user.isActive() && user.hasEmail()) {
        System.out.println("Sending email to " + user.getEmail() + ": " + message);
    } else {
        System.out.println("Could not send email to " + user.getName() + ": User not eligible.");
    }
}

public void logUserActivity(User user, String activity) {
    if (user != null && user.isActive() && user.hasEmail()) { // 重复的条件  
        System.out.println("Logging activity for " + user.getName() + ": " + activity);
    } else {
        System.out.println("Could not log activity for " + user.getName() + ": User not eligible.");
    }
}

重构后：

public void sendNotification(User user, String message) {
    if (!isUserEligible(user)) {
        System.out.println("Could not send email to " + user.getName() + ": User not eligible.");
        return;
    }
    System.out.println("Sending email to " + user.getEmail() + ": " + message);
}

public void logUserActivity(User user, String activity) {
    if (!isUserEligible(user)) { // 复用条件  
        System.out.println("Could not log activity for " + user.getName() + ": User not eligible.");
        return;
    }
    System.out.println("Logging activity for " + user.getName() + ": " + activity);
}

private boolean isUserEligible(User user) {
    return user != null && user.isActive() && user.hasEmail();
}

// 假设 Order 和 OrderType 是 OrderProcessor 策略模式的辅助类  
class Order {
    enum OrderType {STANDARD, PRIORITY}

    private OrderType type;
    private double totalAmount;
    private boolean valid;
    private String name;
    private String email;
    private boolean active;

    // 构造函数、getter/setter等  
    public OrderType getType() {
        return type;
    }

    public double getTotalAmount() {
        return totalAmount;
    }

    public boolean isValid() {
        return valid;
    }

    public String getName() {
        return name;
    }

    public String getEmail() {
        return email;
    }

    public boolean isActive() {
        return active;
    }

    public boolean hasEmail() {
        return email != null && !email.isEmpty();
    } // 假设hasEmail  
}

class User {
    private String name;
    private String email;
    private boolean active;

    // 构造函数、getter/setter等  
    public String getName() {
        return name;
    }

    public String getEmail() {
        return email;
    }

    public boolean isActive() {
        return active;
    }

    public boolean hasEmail() {
        return email != null && !email.isEmpty();
    } // 假设hasEmail  
}