Java新手求助：if-else代码写法规范及优化方案

嘿，作为Java新手能意识到重复代码要优化真的很棒！先聊聊你当前实现里的几个核心问题，再一步步给你落地的优化方案～

你现有代码的问题 #

• 硬编码"魔法值"：直接写"Project Manager"、"Approval"这类字符串，不仅容易拼写错误，后期要修改角色名/操作名时，得在所有用到的地方挨个改，维护成本极高。
• 重复代码冗余：同样的if-else逻辑写3次，完全违反了DRY（Don't Repeat Yourself）原则——一旦逻辑有变化（比如新增角色操作），你得在3个地方同步修改，很容易漏改导致bug。
• 嵌套if可读性差：两层嵌套的条件判断让代码结构混乱，读起来得层层剥开，后期排查问题或扩展逻辑时会很费劲。

优化方案：从简单到进阶 #

第一步：用常量类统一管理魔法值 #

先解决硬编码问题，把所有角色、操作相关的字符串定义成静态常量，这样所有地方都引用常量，避免拼写错误，修改也只需要改一处。

public class ReimbursementConstants {
    // 角色常量
    public static final String ROLE_PROJECT_MANAGER = "Project Manager";
    public static final String ROLE_FINANCE = "Finance";
    // 操作常量
    public static final String ACTION_APPROVAL = "Approval";
    public static final String ACTION_PAYMENT = "Payment";
    // 可根据业务新增其他常量
}

修改后的if-else就变成这样（再也不用怕打错字符串了）：

if (roleName.equalsIgnoreCase(ReimbursementConstants.ROLE_PROJECT_MANAGER)) {
    if (actionsPerform.equalsIgnoreCase(ReimbursementConstants.ACTION_APPROVAL)) {
        reimbursementHistory.setOldStatus(0);
        // 其他业务逻辑...
    }
}

第二步：提取重复逻辑为单独方法 #

接下来解决重复代码问题，把这套if-else逻辑封装成一个独立方法，需要用的地方直接调用即可，不用重复写3遍。

private void updateReimbursementStatus(String roleName, String action, ReimbursementHistory reimbursementHistory) {
    if (roleName.equalsIgnoreCase(ReimbursementConstants.ROLE_PROJECT_MANAGER)) {
        if (action.equalsIgnoreCase(ReimbursementConstants.ACTION_APPROVAL)) {
            reimbursementHistory.setOldStatus(0);
            // 该操作的其他逻辑...
        }
        // 可添加项目经理的其他操作逻辑
    } else if (roleName.equalsIgnoreCase(ReimbursementConstants.ROLE_FINANCE)) {
        if (action.equalsIgnoreCase(ReimbursementConstants.ACTION_PAYMENT)) {
            reimbursementHistory.setOldStatus(1);
            // 该操作的其他逻辑...
        }
        // 可添加财务的其他操作逻辑
    }
    // 其他角色的逻辑
}

调用的时候就简单多了：

// 第一次使用
updateReimbursementStatus(role1, action1, history1);
// 第二次使用
updateReimbursementStatus(role2, action2, history2);
// 第三次使用
updateReimbursementStatus(role3, action3, history3);

第三步：用枚举优化条件判断（进阶） #

如果你的角色和操作组合越来越多，嵌套if会越来越臃肿，这时候可以用枚举来统一管理角色-操作-状态的映射，让逻辑更清晰。

首先定义枚举类：

public enum RoleAction {
    // 枚举实例：角色+操作+对应的旧状态
    PROJECT_MANAGER_APPROVAL(
            ReimbursementConstants.ROLE_PROJECT_MANAGER,
            ReimbursementConstants.ACTION_APPROVAL,
            0
    ),
    FINANCE_PAYMENT(
            ReimbursementConstants.ROLE_FINANCE,
            ReimbursementConstants.ACTION_PAYMENT,
            1
    );
    // 可根据业务新增更多角色-操作组合

    private final String role;
    private final String action;
    private final int oldStatus;

    RoleAction(String role, String action, int oldStatus) {
        this.role = role;
        this.action = action;
        this.oldStatus = oldStatus;
    }

    // 根据角色和操作匹配对应的枚举实例
    public static RoleAction match(String role, String action) {
        for (RoleAction ra : values()) {
            if (ra.role.equalsIgnoreCase(role) && ra.action.equalsIgnoreCase(action)) {
                return ra;
            }
        }
        return null; // 或者抛出异常，根据业务需求处理未知情况
    }

    public int getOldStatus() {
        return oldStatus;
    }
}

然后修改之前的方法，直接用枚举匹配逻辑：

private void updateReimbursementStatus(String roleName, String action, ReimbursementHistory reimbursementHistory) {
    RoleAction matchedAction = RoleAction.match(roleName, action);
    if (matchedAction != null) {
        reimbursementHistory.setOldStatus(matchedAction.getOldStatus());
        // 如果有其他对应逻辑，也可以在枚举里扩展方法处理
    } else {
        // 处理未知角色/操作的情况，比如日志记录或抛出异常
    }
}

这样新增角色-操作组合时，只需要在枚举里加一个实例，完全不用修改方法里的条件判断，扩展性拉满！

第四步：策略模式（高级场景） #

如果每个角色-操作的逻辑不止设置oldStatus，还有更多复杂业务（比如日志记录、通知用户、更新其他字段），可以用策略模式把每个逻辑封装成独立类，符合单一职责原则。

首先定义策略接口：

public interface ReimbursementStrategy {
    void execute(ReimbursementHistory reimbursementHistory);
}

然后实现具体的策略类：

// 项目经理审批的策略
public class ProjectManagerApprovalStrategy implements ReimbursementStrategy {
    @Override
    public void execute(ReimbursementHistory reimbursementHistory) {
        reimbursementHistory.setOldStatus(0);
        // 比如添加日志
        System.out.println("项目经理审批了报销：" + reimbursementHistory.getId());
        // 其他复杂逻辑...
    }
}

// 财务付款的策略
public class FinancePaymentStrategy implements ReimbursementStrategy {
    @Override
    public void execute(ReimbursementHistory reimbursementHistory) {
        reimbursementHistory.setOldStatus(1);
        System.out.println("财务完成报销付款：" + reimbursementHistory.getId());
        // 其他复杂逻辑...
    }
}

更新枚举类，关联对应的策略：

public enum RoleAction {
    PROJECT_MANAGER_APPROVAL(
            ReimbursementConstants.ROLE_PROJECT_MANAGER,
            ReimbursementConstants.ACTION_APPROVAL,
            new ProjectManagerApprovalStrategy()
    ),
    FINANCE_PAYMENT(
            ReimbursementConstants.ROLE_FINANCE,
            ReimbursementConstants.ACTION_PAYMENT,
            new FinancePaymentStrategy()
    );

    private final String role;
    private final String action;
    private final ReimbursementStrategy strategy;

    RoleAction(String role, String action, ReimbursementStrategy strategy) {
        this.role = role;
        this.action = action;
        this.strategy = strategy;
    }

    public static RoleAction match(String role, String action) {
        for (RoleAction ra : values()) {
            if (ra.role.equalsIgnoreCase(role) && ra.action.equalsIgnoreCase(action)) {
                return ra;
            }
        }
        return null;
    }

    public ReimbursementStrategy getStrategy() {
        return strategy;
    }
}

最后调用方法就变得超级简洁：

private void updateReimbursementStatus(String roleName, String action, ReimbursementHistory reimbursementHistory) {
    RoleAction matchedAction = RoleAction.match(roleName, action);
    if (matchedAction != null) {
        matchedAction.getStrategy().execute(reimbursementHistory);
    } else {
        // 处理未知情况
    }
}

总结 #

作为新手，建议你按顺序一步步来：先从常量类+提取方法入手，解决最基础的硬编码和重复代码问题；等对Java更熟悉后，再尝试枚举优化条件判断；如果业务逻辑变得复杂，再考虑策略模式来让代码更易维护和扩展。

内容的提问来源于stack exchange，提问作者Tirth Timaniya