如何在程序中避免出现大量if和case

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

一、使用 策略模式（Strategy Pattern）

最经典、最推荐的方式。

使用场景

当你有一堆“根据类型执行不同逻辑”的判断，比如：

if (type.equals(\"EMAIL\")) { ... }
else if (type.equals(\"SMS\")) { ... }
else if (type.equals(\"PUSH\")) { ... }

优雅改造

定义一个通用接口 NotificationStrategy：

public interface NotificationStrategy {
    void send(String message);
}

不同策略实现类：

@Component(\"EMAIL\")
public class EmailNotificationStrategy implements NotificationStrategy {
    public void send(String message) {
        System.out.println(\"发送邮件: \" + message);
    }
}

@Component(\"SMS\")
public class SmsNotificationStrategy implements NotificationStrategy {
    public void send(String message) {
        System.out.println(\"发送短信: \" + message);
    }
}

工厂自动管理策略：

@Service
public class NotificationService {
    private final Map<String, NotificationStrategy> strategyMap;

    @Autowired
    public NotificationService(Map<String, NotificationStrategy> strategyMap) {
        this.strategyMap = strategyMap;
    }

    public void notify(String type, String message) {
        NotificationStrategy strategy = strategyMap.get(type);
        if (strategy != null) {
            strategy.send(message);
        } else {
            throw new IllegalArgumentException(\"未知通知类型: \" + type);
        }
    }
}

调用：

notificationService.notify(\"EMAIL\", \"你好\");

二、使用 枚举 + Lambda + Map

适合一些轻量级逻辑分派，不用创建一堆类。

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

    private final BiFunction function;

    Operation(BiFunction function) {
        this.function = function;
    }

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

调用：

int result = Operation.MUL.apply(2, 3); // 输出 6

三、使用 Map 映射表（函数表）

适合简单分派逻辑。

Map<String, Runnable> actions = new HashMap();
actions.put(\"A\", () -> System.out.println(\"执行逻辑 A\"));
actions.put(\"B\", () -> System.out.println(\"执行逻辑 B\"));

String type = \"A\";
actions.getOrDefault(type, () -> System.out.println(\"默认逻辑\")).run();

四、使用 责任链模式（Chain of Responsibility）

适合“逐步判断、条件过滤”的业务，比如审批、数据校验。

public abstract class Handler {
    protected Handler next;
    public void setNext(Handler next) { this.next = next; }
    public abstract void handle(Request request);
}

public class AuthHandler extends Handler {
    public void handle(Request req) {
        if (req.isAuthenticated()) {
            if (next != null) next.handle(req);
        } else {
            System.out.println(\"未登录\");
        }
    }
}

链式执行：

authHandler.setNext(validationHandler);
validationHandler.setNext(businessHandler);
authHandler.handle(request);

五、使用 状态模式（State Pattern）

适合“根据状态执行不同逻辑”的情况，比如流程节点、订单状态、任务状态。

public interface State {
    void handle();
}

public class PendingState implements State {
    public void handle() { System.out.println(\"等待审批\"); }
}

public class ApprovedState implements State {
    public void handle() { System.out.println(\"已通过\"); }
}

上下文：

public class Context {
    private State state;
    public void setState(State state) { this.state = state; }
    public void handle() { state.handle(); }
}

六、反射 + 注解（高级玩法）

可以用自定义注解 + 扫描注册的方式，动态调用方法，而不用写 case：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ActionType {
    String value();
}

定义方法：

@ActionType(\"A\")
public void doA() { ... }

@ActionType(\"B\")
public void doB() { ... }

初始化时扫描并放入 Map，根据类型动态调用。

总结对比