Java 代码中 if/switch 重构方案

在 Java 开发中，想要避免出现大量 if...else 或 switch...case，可以使用多种设计模式和技巧来“消除条件分支”。下面总结几种常用、实战有效的方案。

1. 使用枚举 + Lambda

适合一些轻量级逻辑分派。

package com.example.demo.enums;

import lombok.AllArgsConstructor;

import java.util.function.BiFunction;

@AllArgsConstructor
public enum OperationEnum {
    ADD((a, b) -> a + b),
    SUB((a, b) -> a - b),
    MUL((a, b) -> a * b),
    DIV((a, b) -> a / b);

    private final BiFunction<Integer, Integer, Integer> function;

    public int apply(int a, int b) {
        return function.apply(a, b);
    }
}

使用代码，方法参数传递过来一个枚举，直接调用 apply 方法就行：

public static void main(String[] args) {
    int result = operation(OperationEnum.MUL, 2, 3);
    System.out.println(result);
}

//这个方法减少了ifelse判断
private static int operation(OperationEnum operationEnum, int a, int b) {
    return operationEnum.apply(a, b);
}

2. 使用枚举 + Lambda + Map

适合简单分派逻辑。

package com.example.demo.enums;

import lombok.AllArgsConstructor;
import lombok.Getter;

@Getter
@AllArgsConstructor
public enum ActionEnum {

    ACTION_A("A"),
    ACTION_B("B");

    private final String action;
}

package com.example.demo.handler;

import com.example.demo.enums.ActionEnum;

import java.util.HashMap;
import java.util.Map;

public class ActionHandler {
    private static final Map<String, Runnable> ACTION = new HashMap<>();

    static {
        ACTION.put(ActionEnum.ACTION_A.getAction(), () -> System.out.println("执行逻辑 A"));
        ACTION.put(ActionEnum.ACTION_B.getAction(), () -> System.out.println("执行逻辑 B"));
    }

    public static void execute(ActionEnum actionEnum) {
        ACTION.getOrDefault(actionEnum.getAction(), () -> System.out.println("默认逻辑")).run();
    }
}

使用代码：

ActionHandler.execute(ActionEnum.ACTION_A);

3. 使用责任链模式

适合逐步判断、条件过滤的业务，比如审批、数据校验。可自由扩展处理链，避免多层 if 嵌套。

首先提供一个抽象类，Request是个辅助类，可根据真实业务修改：

package com.example.demo.handler;

import lombok.Data;

@Data
public class Request {
    private boolean authenticated;
    private boolean validate;
}

package com.example.demo.handler;

import lombok.Setter;

public abstract class Handler {
    @Setter
    protected Handler next;

    public abstract void handle(Request request);
}

三个继承抽象类的子类：

package com.example.demo.handler;

public class AuthHandler extends Handler {
    @Override
    public void handle(Request request) {
        if (request.isAuthenticated()) {
            System.out.println("login success");
            if (next != null) {
                next.handle(request);
            }
        } else {
            System.out.println("login fail");
        }
    }
}

package com.example.demo.handler;

public class ValidationHandler extends Handler{
    @Override
    public void handle(Request request) {
        if (request.isValidate()){
            System.out.println("validation success");
            if (next != null) {
                next.handle(request);
            }
        }else {
            System.out.println("validation failed");
        }
    }
}

package com.example.demo.handler;

public class BusinessHandler extends Handler {
    @Override
    public void handle(Request request) {
        System.out.println("start handler business");
    }
}

使用代码：

Request request = new Request();
request.setAuthenticated(true);
request.setValidate(true);
AuthHandler authHandler = new AuthHandler();
ValidationHandler validationHandler = new ValidationHandler();
BusinessHandler businessHandler = new BusinessHandler();
//设置处理顺序
authHandler.setNext(validationHandler);
validationHandler.setNext(businessHandler);
//开始触发执行
authHandler.handle(request);

执行结果：

login success
validation success
start handler business

4. 使用策略模式

参考我的另一篇博文：SpringBoot 优雅实现接口的多实现类方式