枚举类型的设计哲学与用法

Java 枚举（enum）不仅是常量集合，更是功能完整的类。本文从设计哲学到高级用法，全面解析枚举类型。

枚举的本质

编译后的枚举是一个继承 java.lang.Enum 的 final 类：

// 源代码
public enum Status {
    ACTIVE, INACTIVE, DELETED;
}

// 编译后（等价形式）
public final class Status extends Enum<Status> {
    public static final Status ACTIVE = new Status("ACTIVE", 0);
    public static final Status INACTIVE = new Status("INACTIVE", 1);
    public static final Status DELETED = new Status("DELETED", 2);
    
    private Status(String name, int ordinal) {
        super(name, ordinal);
    }
}

基础用法

带属性和方法的枚举

public enum Status {
    ACTIVE(1, "活跃"),
    INACTIVE(0, "未激活"),
    DELETED(-1, "已删除");
    
    private final int code;
    private final String desc;
    
    Status(int code, String desc) {
        this.code = code;
        this.desc = desc;
    }
    
    public int getCode() { return code; }
    public String getDesc() { return desc; }
    
    // 根据code查找枚举
    public static Status fromCode(int code) {
        for (Status s : values()) {
            if (s.code == code) return s;
        }
        throw new IllegalArgumentException("无效的状态码: " + code);
    }
}

枚举常用方法

Status s = Status.ACTIVE;

// 基本方法
String name = s.name();           // "ACTIVE"
int ordinal = s.ordinal();        // 0

// 类方法
Status[] all = Status.values();   // 所有枚举值
Status parsed = Status.valueOf("ACTIVE");  // 从字符串解析

// 比较
boolean isActive = s == Status.ACTIVE;  // 可以用==比较

枚举实现单例模式

枚举是实现单例的最佳方式：

public enum Singleton {
    INSTANCE;
    
    private String config;
    
    public void doSomething() {
        System.out.println("Doing something...");
    }
    
    public String getConfig() {
        return config;
    }
    
    public void setConfig(String config) {
        this.config = config;
    }
}

// 使用
Singleton.INSTANCE.doSomething();

优势：

线程安全（由 JVM 保证）
防止反射攻击
防止反序列化创建新实例

策略枚举模式

用枚举实现策略模式：

public enum Calculator {
    ADD {
        @Override
        public double apply(double a, double b) {
            return a + b;
        }
    },
    SUBTRACT {
        @Override
        public double apply(double a, double b) {
            return a - b;
        }
    },
    MULTIPLY {
        @Override
        public double apply(double a, double b) {
            return a * b;
        }
    },
    DIVIDE {
        @Override
        public double apply(double a, double b) {
            if (b == 0) throw new ArithmeticException("除数不能为0");
            return a / b;
        }
    };
    
    public abstract double apply(double a, double b);
}

// 使用
double result = Calculator.ADD.apply(10, 5);  // 15.0

状态机实现

public enum OrderState {
    CREATED {
        @Override
        public boolean canTransitionTo(OrderState newState) {
            return newState == PAID || newState == CANCELLED;
        }
    },
    PAID {
        @Override
        public boolean canTransitionTo(OrderState newState) {
            return newState == SHIPPED || newState == REFUNDING;
        }
    },
    SHIPPED {
        @Override
        public boolean canTransitionTo(OrderState newState) {
            return newState == COMPLETED || newState == REFUNDING;
        }
    },
    COMPLETED {
        @Override
        public boolean canTransitionTo(OrderState newState) {
            return newState == REFUNDING;
        }
    },
    CANCELLED,
    REFUNDING,
    REFUNDED;
    
    public boolean canTransitionTo(OrderState newState) {
        return false;  // 默认不允许转换
    }
}

// 状态转换检查
public void transition(OrderState from, OrderState to) {
    if (!from.canTransitionTo(to)) {
        throw new IllegalStateException(
            "不能从 " + from + " 转换到 " + to);
    }
    // 执行转换
}

接口实现

枚举可以实现接口：

public interface Operation {
    double apply(double a, double b);
}

public enum BasicOperation implements Operation {
    PLUS("+") {
        public double apply(double a, double b) { return a + b; }
    },
    MINUS("-") {
        public double apply(double a, double b) { return a - b; }
    };
    
    private final String symbol;
    
    BasicOperation(String symbol) {
        this.symbol = symbol;
    }
    
    @Override
    public String toString() {
        return symbol;
    }
}

实际业务场景

支付渠道枚举

public enum PaymentChannel {
    ALIPAY("支付宝", "https://alipay.com/gateway"),
    WECHAT("微信支付", "https://api.mch.weixin.qq.com"),
    UNIONPAY("银联", "https://gateway.95516.com");
    
    private final String name;
    private final String gatewayUrl;
    
    PaymentChannel(String name, String gatewayUrl) {
        this.name = name;
        this.gatewayUrl = gatewayUrl;
    }
    
    // getter...
}

与数据库映射

// JPA 转换器
@Converter(autoApply = true)
public class StatusConverter implements AttributeConverter<Status, Integer> {
    @Override
    public Integer convertToDatabaseColumn(Status status) {
        return status != null ? status.getCode() : null;
    }
    
    @Override
    public Status convertToEntityAttribute(Integer code) {
        return code != null ? Status.fromCode(code) : null;
    }
}

最佳实践

枚举名使用大写：这是 Java 的命名约定
不要依赖 ordinal()：新增枚举值可能导致顺序变化
为枚举添加 fromXxx 工厂方法：便于从数据库/前端转换
慎用复杂枚举：如果枚举逻辑过于复杂，考虑使用策略类
序列化安全：枚举天然支持序列化，且保证单例

// 好的做法：显式定义code，不依赖ordinal
public enum Priority {
    LOW(1),
    MEDIUM(2),
    HIGH(3),
    URGENT(4);
    
    private final int code;
    Priority(int code) { this.code = code; }
    public int getCode() { return code; }
}