Java枚举通用接口设计与实现方法举例

/**
 * @description 枚举基础接口
 */
public interface BaseEnumInterface<T> {

    /**
     * 获取枚举编码
     * @return 编码值
     */
    T getCode();

    /**
     * 获取枚举描述
     * @return 描述信息
     */
    String getDesc();

    /**
     * 根据 code 获取枚举实例（通用方法）
     * @param enumClass 枚举类
     * @param code 编码
     * @return 枚举实例
     * @param <E> 枚举类型
     * @param <T> 编码类型
     */
    static <E extends Enum<E> & BaseEnumInterface<T>, T> E fromCode(Class<E> enumClass, T code) {
        for (E e : enumClass.getEnumConstants()) {
            if (e.getCode().equals(code)) {
                return e;
            }
        }
        return null;
    }

    /**
     * 根据 code 获取枚举实例，如果找不到则返回默认值
     * @param enumClass 枚举类
     * @param code 编码
     * @param defaultEnum 默认枚举值
     * @return 枚举实例
     * @param <E> 枚举类型
     * @param <T> 编码类型
     */
    static <E extends Enum<E> & BaseEnumInterface<T>, T> E fromCodeOrDefault(Class<E> enumClass, T code, E defaultEnum) {
        E result = fromCode(enumClass, code);
        return result != null ? result : defaultEnum;
    }

    /**
     * 根据描述获取枚举实例
     * @param enumClass 枚举类
     * @param desc 描述
     * @return 枚举实例
     * @param <E> 枚举类型
     */
    static <E extends Enum<E> & BaseEnumInterface<?>> E fromDesc(Class<E> enumClass, String desc) {
        for (E e : enumClass.getEnumConstants()) {
            if (e.getDesc().equals(desc)) {
                return e;
            }
        }
        return null;
    }

    /**
     * 获取所有枚举的编码列表
     * @param enumClass 枚举类
     * @return 编码列表
     * @param <E> 枚举类型
     * @param <T> 编码类型
     */
    static <E extends Enum<E> & BaseEnumInterface<T>, T> List<T> getAllCodes(Class<E> enumClass) {
        return Arrays.stream(enumClass.getEnumConstants())
                .map(e -> ((BaseEnumInterface<T>) e).getCode())  // 修改此处
                .collect(Collectors.toList());
    }

    /**
     * 获取所有枚举的描述列表
     * @param enumClass 枚举类
     * @return 描述列表
     * @param <E> 枚举类型
     */
    static <E extends Enum<E> & BaseEnumInterface<?>> List<String> getAllDescs(Class<E> enumClass) {
        return Arrays.stream(enumClass.getEnumConstants())
                .map(e -> ((BaseEnumInterface<?>) e).getDesc())  // 修改此处
                .collect(Collectors.toList());
    }

    /**
     * 获取枚举编码到描述的映射
     * @param enumClass 枚举类
     * @return 编码到描述的映射
     * @param <E> 枚举类型
     * @param <T> 编码类型
     */
    static <E extends Enum<E> & BaseEnumInterface<T>, T> Map<T, String> getCodeToDescMap(Class<E> enumClass) {
        return Arrays.stream(enumClass.getEnumConstants())
                .collect(Collectors.toMap(
                        e -> ((BaseEnumInterface<T>) e).getCode(),  // 修改此处
                        e -> ((BaseEnumInterface<T>) e).getDesc()   // 修改此处
                ));
    }

    /**
     * 获取枚举描述到编码的映射
     * @param enumClass 枚举类
     * @return 描述到编码的映射
     * @param <E> 枚举类型
     * @param <T> 编码类型
     */
    static <E extends Enum<E> & BaseEnumInterface<T>, T> Map<String, T> getDescToCodeMap(Class<E> enumClass) {
        return Arrays.stream(enumClass.getEnumConstants())
                .collect(Collectors.toMap(
                        e -> ((BaseEnumInterface<T>) e).getDesc(),  // 修改此处
                        e -> ((BaseEnumInterface<T>) e).getCode()   // 修改此处
                ));
    }

    /**
     * 检查给定的编码是否有效
     * @param enumClass 枚举类
     * @param code 编码
     * @return 是否有效
     * @param <E> 枚举类型
     * @param <T> 编码类型
     */
    static <E extends Enum<E> & BaseEnumInterface<T>, T> boolean isValidCode(Class<E> enumClass, T code) {
        return fromCode(enumClass, code) != null;
    }

    /**
     * 获取枚举实例列表
     * @param enumClass 枚举类
     * @return 枚举实例列表
     * @param <E> 枚举类型
     */
    static <E extends Enum<E> & BaseEnumInterface<?>> List<E> getAllEnums(Class<E> enumClass) {
        return Arrays.asList(enumClass.getEnumConstants());
    }
}

/**
 * 性别枚举
 */
public enum GenderEnum implements BaseEnumInterface<Integer> {
    /**
     * 男性
     */
    MALE(1, "男"),
    
    /**
     * 女性
     */
    FEMALE(2, "女"),
    
    /**
     * 未知
     */
    UNKNOWN(0, "未知");

    private final Integer code;
    private final String desc;

    GenderEnum(Integer code, String desc) {
        this.code = code;
        this.desc = desc;
    }

    @Override
    public Integer getCode() {
        return code;
    }

    @Override
    public String getDesc() {
        return desc;
    }
}

/**
 * 性别枚举测试类
 */
@Slf4j
@Component
public class GenderEnumTest {

    public static void main(String[] args) {

        log.info("=== 性别枚举测试 ===");

        // 1. 测试根据code获取枚举实例
        GenderEnum male = BaseEnumInterface.fromCode(GenderEnum.class, 1);
        log.info("code为1的枚举: {}", male);
        log.info("code为1的枚举描述: {}", male.getDesc());

        GenderEnum female = BaseEnumInterface.fromCode(GenderEnum.class, 2);
        log.info("code为2的枚举: {}", female);
        log.info("code为2的枚举描述: {}", female.getDesc());

        // 2. 测试根据code获取枚举实例（带默认值）
        GenderEnum defaultGender = BaseEnumInterface.fromCodeOrDefault(GenderEnum.class, 99, GenderEnum.UNKNOWN);
        log.info("code为99的枚举(默认值): {}", defaultGender);

        // 3. 测试根据描述获取枚举实例
        GenderEnum byDesc = BaseEnumInterface.fromDesc(GenderEnum.class, "男");
        log.info("描述为'男'的枚举: {}", byDesc);

        // 4. 测试获取所有枚举的编码列表
        List<Integer> allCodes = BaseEnumInterface.getAllCodes(GenderEnum.class);
        log.info("所有枚举编码: {}", allCodes);

        // 5. 测试获取所有枚举的描述列表
        List<String> allDescs = BaseEnumInterface.getAllDescs(GenderEnum.class);
        log.info("所有枚举描述: {}", allDescs);

        // 6. 测试获取编码到描述的映射
        Map<Integer, String> codeToDescMap = BaseEnumInterface.getCodeToDescMap(GenderEnum.class);
        log.info("编码到描述的映射: {}", codeToDescMap);

        // 7. 测试获取描述到编码的映射
        Map<String, Integer> descToCodeMap = BaseEnumInterface.getDescToCodeMap(GenderEnum.class);
        log.info("描述到编码的映射: {}", descToCodeMap);

        // 8. 测试检查编码是否有效
        boolean validCode1 = BaseEnumInterface.isValidCode(GenderEnum.class, 1);
        boolean validCode99 = BaseEnumInterface.isValidCode(GenderEnum.class, 99);
        log.info("编码1是否有效: {}", validCode1);
        log.info("编码99是否有效: {}", validCode99);

        // 9. 测试获取所有枚举实例
        List<GenderEnum> allEnums = BaseEnumInterface.getAllEnums(GenderEnum.class);
        log.info("所有枚举实例:");
        allEnums.forEach(e -> log.info("  {} - code: {}, desc: {}", e.name(), e.getCode(), e.getDesc()));
    }
}