enum枚举类优化-CFANZ编程社区

在这里插入图片描述
那有没有办法让所有枚举类只保留getter方法，去除其他重复冗余静态方法？
聪明的你们一定想到了类似面向接口编程的方式，我们可以先定义一个最简单的只有枚举value的接口，并让其支持泛型，因为有的枚举类并不需要枚举名且枚举value可能是String或Integer等，
接着我们可以在定义一个NameValueEnum接口让其继承前面的ValueEnum接口，这样就可以满足需要枚举value和枚举name的枚举类了。
有了以上两个接口，就可以覆盖大部分枚举类的需求了，接着就可以定义EnumUtils类的编写我们经常需要用到的重复冗余代码了。

定义带有泛型的只有枚举value的接口

public interface ValueEnum<T> {

    /**
     * 获取枚举值
     * @return 枚举值
     */
    T getValue();

}

定义一个NameValueEnum的接口，并让其继承ValueEnum接口

public interface NameValueEnum<T> extends ValueEnum<T> {

    /**
     * 获取枚举名称
     * @return 枚举名称
     */
     String getName();

}

定义EnumUtils工具类

import org.springframework.util.StringUtils;

public class EnumUtils {

    /**
     * 判断枚举值是否合法有效
     *
     * @param enums 某个枚举的所有值
     * @param value 指定值
     * @param <T>
     * @return true:合法 false:非法
     */
    public static <T> boolean isExist(ValueEnum<T>[] enums, T value) {
        if (value == null) {
            return false;
        }
        for (ValueEnum<T> e : enums) {
            if (value.equals(e.getValue())) {
                return true;
            }
        }
        return false;
    }

    /**
     * 判断枚举值是否存在与指定枚举类中
     * @param enumClass 枚举类
     * @param value 枚举值
     * @param <E>   枚举类型
     * @param <V>   值类型
     * @return true:存在
     */
    public static <E extends Enum<? extends ValueEnum<V>>, V> boolean isExist(Class<E> enumClass, V value) {

        for (Enum<? extends ValueEnum<V>> e : enumClass.getEnumConstants()) {
            if (((ValueEnum<V>) e).getValue().equals(value)) {
                return true;
            }
        }
        return false;
    }

    /**
     *
     * @param enums
     * @param value
     * @param <T>
     * @return 枚举名称
     */
    public static <T> String getNameByValue(NameValueEnum<T>[] enums,T value){
        if (value == null) {
            return null;
        }
        for (NameValueEnum<T> e : enums) {
            if (value.equals(e.getValue())) {
                return e.getName();
            }
        }
        return null;
    }

    /**
     * 根据枚举名称获取对应的枚举值
     * @param enums 枚举列表
     * @param name  枚举名
     * @param <T>   枚举类型
     * @return      枚举值
     */
    public static <T> T getValueByName(NameValueEnum<T>[] enums,String name){
        if (StringUtils.isEmpty(name)) {
            return null;
        }
        for (NameValueEnum<T> e : enums) {
            if (name.equals(e.getName())) {
                return e.getValue();
            }
        }
        return null;
    }

    /**
     * 根据枚举值获取对应的枚举对象
     * @param enumClass 枚举class
     * @param value     枚举对象
     * @param <E>
     * @param <V>
     * @return
     */
    public static  <E extends Enum<? extends ValueEnum<V>>, V> E getEnumByValue(Class<E> enumClass, V value) {
        return getEnumByValue(enumClass.getEnumConstants(), value);
    }

    /**
     * 根据枚举值获取对应的枚举对象
     * @param enums     枚举列表
     * @param value
     * @param <E>
     * @param <V>
     * @return          枚举对象
     */
    private static <E extends Enum<? extends ValueEnum<V>>, V> E getEnumByValue(E[] enums, V value) {
        for (E e : enums) {
            if(((ValueEnum<V>) e).getValue().equals(value)){
                return e;
            }
        }
        return null;
    }
}

枚举类只要实现了上述接口，通过枚举类的values方法获取的所有枚举对象值都可以向上转型为接口类型数组，最后就是实践环节了。

定义两种不同的枚举类，并让其实现NameValueEnum接口

//定义一个value为String的枚举类
public enum TestStrEnum implements NameValueEnum<String> {
    T1("01","String类型测试1"),
    T2("02","String类型测试2");

    private final String value;
    private final String name;

    TestStrEnum(String value,String name){
        this.name = name;
        this.value = value;
    }

    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public String getValue() {
        return this.value;
    }
}

//定义一个value为Integer的枚举类
public enum TestIntEnum implements NameValueEnum<Integer> {
    T1(1,"Integer型测试1"),
    T2(2,"Integer类型测试2");

    private final Integer value;
    private final String name;

    TestIntEnum(Integer value, String name){
        this.name = name;
        this.value = value;
    }

    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public Integer getValue() {
        return this.value;
    }
}

写单元测试，完美的全部运行成功

import org.junit.Assert;
import org.junit.Test;

public class EnumTest {

    @Test
    public void isExist(){
        Assert.assertTrue(EnumUtils.isExist(TestStrEnum.values(), "01"));
        Assert.assertFalse(EnumUtils.isExist(TestStrEnum.values(), "03"));

        Assert.assertTrue(EnumUtils.isExist(TestIntEnum.class, 1));
        Assert.assertFalse(EnumUtils.isExist(TestIntEnum.class, 3));
    }

    @Test
    public void getNameByValue(){
        String name = EnumUtils.getNameByValue(TestStrEnum.values(), "01");
        String name2 = EnumUtils.getNameByValue(TestIntEnum.values(), 2);
        System.out.println(name);
        System.out.println(name2);
    }

    @Test
    public void getValueByName(){
        String value = EnumUtils.getValueByName(TestStrEnum.values(), "String类型测试1");
        Integer value2 = EnumUtils.getValueByName(TestIntEnum.values(), "Integer类型测试2");
        System.out.println(value);
        System.out.println(value2);
    }

    @Test
    public void getEnumByValue(){
        TestStrEnum enumByValue = EnumUtils.getEnumByValue(TestStrEnum.class, "01");
        TestIntEnum enumByValue1 = EnumUtils.getEnumByValue(TestIntEnum.class, 2);
        System.out.println(enumByValue);
        System.out.println(enumByValue1);
    }

}