枚举类型应用场景

场景一：状态/类型定义（最常用）
用枚举代替 int 或 String 常量，增强代码可读性和类型安全性。

java
public enum OrderStatus {
PENDING("待支付"),
PAID("已支付"),
SHIPPED("已发货"),
COMPLETED("已完成"),
CANCELLED("已取消");

private String description;

OrderStatus(String description) {
this.description = description;
}

public String getDescription() {
return description;
}
}

public class StateExample {
public static void main(String[] args) {
OrderStatus status = OrderStatus.PAID;
switch (status) {
case PENDING:
System.out.println("请完成支付");
break;
case PAID:
System.out.println("等待发货");
break;
case SHIPPED:
System.out.println("商品已发出");
break;
case COMPLETED:
System.out.println("交易完成");
break;
case CANCELLED:
System.out.println("订单已取消");
break;
}
}
}

场景二：策略模式（替换大量if/else）
将不同策略封装在枚举中，避免写大量 if-else。

java
public enum Calculator {
ADD("+") {
public int calculate(int a, int b) { return a + b; }
},
SUBTRACT("-") {
public int calculate(int a, int b) { return a - b; }
},
MULTIPLY("*") {
public int calculate(int a, int b) { return a * b; }
},
DIVIDE("/") {
public int calculate(int a, int b) { return a / b; }
};

private String symbol;
Calculator(String symbol) { this.symbol = symbol; }
public String getSymbol() { return symbol; }
public abstract int calculate(int a, int b);
}

public class StrategyExample {
public static void main(String[] args) {
int a = 10, b = 5;
System.out.println(Calculator.ADD.calculate(a, b)); // 15
System.out.println(Calculator.SUBTRACT.calculate(a, b));// 5
System.out.println(Calculator.MULTIPLY.calculate(a, b));// 50
System.out.println(Calculator.DIVIDE.calculate(a, b)); // 2
}
}

场景三：统一返回码（后端接口必备）
定义统一返回码枚举，规范接口响应格式。

java
public enum ResultCode {
SUCCESS(200, "操作成功"),
ERROR(500, "操作失败"),
BAD_REQUEST(400, "请求参数错误"),
UNAUTHORIZED(401, "未授权"),
NOT_FOUND(404, "资源不存在");

private int code;
private String message;

ResultCode(int code, String message) {
this.code = code;
this.message = message;
}

public int getCode() { return code; }
public String getMessage() { return message; }
}

class ApiResponse {
private int code;
private String message;
private T data;

public ApiResponse(ResultCode resultCode, T data) {
this.code = resultCode.getCode();
this.message = resultCode.getMessage();
this.data = data;
}

public static ApiResponse success(T data) {
return new ApiResponse<>(ResultCode.SUCCESS, data);
}

public static ApiResponse error(ResultCode resultCode) {
return new ApiResponse<>(resultCode, null);
}
}

public class ResultCodeExample {
public static void main(String[] args) {
ApiResponse resp = ApiResponse.success("用户数据");
System.out.println("code: " + resp.getCode()); // 200
System.out.println("message: " + resp.getMessage());// 操作成功
System.out.println("data: " + resp.getData()); // 用户数据
}
}

枚举在Java中有三个非常实用的应用场景：

状态/类型定义：用枚举代替整数或字符串常量来表示各种状态（如订单状态、用户角色），代码更安全、更易读，编译器会帮你检查是否用了非法值。

策略模式：让枚举的每个常量都实现同一个抽象方法，每个常量有自己的行为逻辑。这样可以彻底消灭大量的 if-else 或 switch 语句，扩展起来也很方便。

统一返回码：在后端开发中，用枚举集中管理所有的状态码和提示信息，配合统一响应类，保证整个项目的接口返回格式一致，便于前后端协作。

枚举的本质是一种特殊的类，它可以有属性和方法，每个枚举常量都是该类的一个实例。正是因为这个特性，枚举才能做到上面这些普通常量无法做到的事情。