Java枚举判断案例如何实操

wen java案例 2026-07-01 210

本文目录导读：

Java枚举判断案例如何实操

基础枚举判断
枚举带属性判断
高级判断技巧
实际业务场景
最佳实践

我来详细讲解Java枚举判断的实操案例,从基础到进阶。

基础枚举判断

1 简单的状态判断

enum Status {
    PENDING, PROCESSING, COMPLETED, FAILED
}
public class OrderService {
    public void processOrder(Status status) {
        // 使用switch判断
        switch (status) {
            case PENDING:
                System.out.println("订单待处理");
                break;
            case PROCESSING:
                System.out.println("订单处理中");
                break;
            case COMPLETED:
                System.out.println("订单已完成");
                break;
            case FAILED:
                System.out.println("订单失败");
                break;
        }
        // 或者使用if-else判断
        if (status == Status.PENDING) {
            System.out.println("需要立即处理");
        } else if (status == Status.COMPLETED) {
            System.out.println("订单已完成");
        }
    }
}

枚举带属性判断

1 带字段的枚举

enum OrderStatus {
    PENDING(0, "待支付", "黄色"),
    PAID(1, "已支付", "蓝色"),
    SHIPPED(2, "已发货", "绿色"),
    DELIVERED(3, "已送达", "蓝色"),
    CANCELLED(-1, "已取消", "红色");
    private final int code;
    private final String description;
    private final String color;
    OrderStatus(int code, String description, String color) {
        this.code = code;
        this.description = description;
        this.color = color;
    }
    // Getter方法
    public int getCode() { return code; }
    public String getDescription() { return description; }
    public String getColor() { return color; }
    // 根据code获取枚举
    public static OrderStatus fromCode(int code) {
        for (OrderStatus status : values()) {
            if (status.code == code) {
                return status;
            }
        }
        throw new IllegalArgumentException("未知状态码: " + code);
    }
    // 判断是否可以取消
    public boolean canCancel() {
        return this == PENDING || this == PAID;
    }
    // 判断是否可以退款
    public boolean canRefund() {
        return this == PAID || this == SHIPPED;
    }
}

2 业务逻辑判断

public class OrderManager {
    // 根据数据库状态码判断
    public void updateOrderStatus(int statusCode) {
        OrderStatus status = OrderStatus.fromCode(statusCode);
        switch (status) {
            case PENDING:
                handlePendingOrder();
                break;
            case PAID:
                handlePaidOrder();
                break;
            // ... 其他状态处理
        }
    }
    // 复杂的业务逻辑判断
    public boolean canProcessOrder(OrderStatus currentStatus, int userLevel) {
        // 组合条件判断
        if (currentStatus == OrderStatus.PENDING && userLevel >= 1) {
            return true;
        }
        if (currentStatus == OrderStatus.PAID && userLevel >= 2) {
            return true;
        }
        // 使用枚举方法判断
        if (currentStatus.canCancel() && userLevel >= 3) {
            return true;
        }
        return false;
    }
}

高级判断技巧

1 使用Map存储状态机

enum State {
    INIT, APPROVED, REJECTED, COMPLETED;
    // 定义状态转换规则
    private static final Map<State, List<State>> transitions = new HashMap<>();
    static {
        transitions.put(INIT, Arrays.asList(APPROVED, REJECTED));
        transitions.put(APPROVED, Arrays.asList(COMPLETED, REJECTED));
        transitions.put(REJECTED, Collections.emptyList());
        transitions.put(COMPLETED, Collections.emptyList());
    }
    // 判断是否可以转换到目标状态
    public boolean canTransitionTo(State target) {
        List<State> allowedStates = transitions.get(this);
        return allowedStates != null && allowedStates.contains(target);
    }
    // 执行状态转换
    public State transition(State target) {
        if (!canTransitionTo(target)) {
            throw new IllegalStateException(
                String.format("无法从 %s 转换到 %s", this, target));
        }
        return target;
    }
}

2 枚举策略模式

enum DiscountType {
    NEW_USER("新用户优惠") {
        @Override
        public double calculate(double amount) {
            return amount * 0.8; // 8折
        }
        @Override
        public boolean isApplicable(User user) {
            return user.isNewUser();
        }
    },
    VIP("VIP优惠") {
        @Override
        public double calculate(double amount) {
            return amount * 0.7; // 7折
        }
        @Override
        public boolean isApplicable(User user) {
            return user.isVip();
        }
    },
    SEASONAL("季节性优惠") {
        @Override
        public double calculate(double amount) {
            return amount * 0.85; // 8.5折
        }
        @Override
        public boolean isApplicable(User user) {
            return checkSeason(user);
        }
    };
    private String name;
    DiscountType(String name) {
        this.name = name;
    }
    public abstract double calculate(double amount);
    public abstract boolean isApplicable(User user);
    // 获取用户可用的最佳折扣
    public static DiscountType getBestDiscount(User user, double amount) {
        DiscountType best = null;
        double maxDiscount = 0;
        for (DiscountType type : values()) {
            if (type.isApplicable(user)) {
                double discount = amount - type.calculate(amount);
                if (discount > maxDiscount) {
                    maxDiscount = discount;
                    best = type;
                }
            }
        }
        return best;
    }
}

实际业务场景

1 权限判断

enum Permission {
    READ(1, "读取"),
    WRITE(2, "写入"),
    DELETE(3, "删除"),
    ADMIN(4, "管理");
    private final int level;
    private final String description;
    Permission(int level, String description) {
        this.level = level;
        this.description = description;
    }
    // 判断用户是否有权限
    public static boolean hasPermission(User user, Permission required) {
        // 管理员拥有所有权限
        if (user.getRole() == Role.ADMIN) {
            return true;
        }
        // 根据用户角色判断权限
        switch (user.getRole()) {
            case EDITOR:
                return required == READ || required == WRITE;
            case VIEWER:
                return required == READ;
            default:
                return false;
        }
    }
}

2 支付方式判断

enum PaymentMethod {
    ALIPAY("支付宝", true) {
        @Override
        public void process(PaymentRequest request) {
            // 支付宝支付处理逻辑
            System.out.println("通过支付宝处理支付");
        }
    },
    WECHAT("微信支付", true) {
        @Override
        public void process(PaymentRequest request) {
            // 微信支付处理逻辑
            System.out.println("通过微信处理支付");
        }
    },
    BANK_CARD("银行卡", true) {
        @Override
        public void process(PaymentRequest request) {
            // 银行卡支付处理逻辑
            System.out.println("通过银行卡处理支付");
        }
    },
    CREDIT("信用支付", false) {
        @Override
        public void process(PaymentRequest request) {
            // 信用支付处理逻辑
            if (!this.isAvailable()) {
                throw new UnsupportedOperationException("信用支付暂不可用");
            }
            System.out.println("通过信用支付处理");
        }
    };
    private final String displayName;
    private final boolean available;
    PaymentMethod(String displayName, boolean available) {
        this.displayName = displayName;
        this.available = available;
    }
    public abstract void process(PaymentRequest request);
    public boolean isAvailable() {
        return available;
    }
    // 根据用户选择进行支付
    public static PaymentResult pay(String method, User user, double amount) {
        PaymentMethod paymentMethod = valueOf(method.toUpperCase());
        // 判断支付方式是否可用
        if (!paymentMethod.isAvailable()) {
            return PaymentResult.failed("该支付方式暂不可用");
        }
        // 判断用户是否有权限使用该支付方式
        if (!user.canUsePayment(paymentMethod)) {
            return PaymentResult.failed("您没有权限使用该支付方式");
        }
        // 执行支付
        try {
            PaymentRequest request = new PaymentRequest(user, amount);
            paymentMethod.process(request);
            return PaymentResult.success();
        } catch (Exception e) {
            return PaymentResult.failed("支付失败: " + e.getMessage());
        }
    }
}

最佳实践

1 判空处理

public class EnumUtils {
    // 安全获取枚举
    public static <T extends Enum<T>> T safeValueOf(Class<T> enumClass, String name) {
        if (name == null || name.isEmpty()) {
            return null;
        }
        try {
            return Enum.valueOf(enumClass, name.toUpperCase());
        } catch (IllegalArgumentException e) {
            return null;
        }
    }
    // 安全的枚举判断
    public static boolean isEnumValue(String name, Class<? extends Enum> enumClass) {
        return safeValueOf(enumClass, name) != null;
    }
}

2 完整示例

// 使用时避免空指针
public class EnumDemo {
    public static void main(String[] args) {
        // 正确的判断方式
        String statusStr = "COMPLETED";
        OrderStatus status = EnumUtils.safeValueOf(OrderStatus.class, statusStr);
        if (status != null) {
            System.out.println("状态描述: " + status.getDescription());
            // 使用枚举方法判断
            if (status.canCancel()) {
                System.out.println("可以取消订单");
            }
        }
        // 多个状态的判断
        List<OrderStatus> validStatuses = Arrays.asList(
            OrderStatus.PAID, 
            OrderStatus.SHIPPED
        );
        if (validStatuses.contains(status)) {
            System.out.println("订单处于有效状态");
        }
        // 使用Stream进行批量判断
        boolean anyMatch = Arrays.stream(OrderStatus.values())
            .anyMatch(s -> s.getCode() > 0);
    }
}

通过以上案例，你可以看到Java枚举判断的多种实现方式，掌握这些技巧可以帮助你写出更清晰、更安全的代码,关键是要根据实际业务场景选择合适的判断方式。

本文地址： https://bmjup.com/post/13240.html