java动态添加枚举值，实现枚举值的动态扩展

已于 2022-10-28 15:18:08 修改
阅读量2.1k 收藏 5
点赞数
分类专栏： java 文章标签： java jvm 开发语言
于 2022-08-24 19:35:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013813491/article/details/126511277
版权

直接上代码：

加入lombok依赖：

<dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.36</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
            <version>1.2.11</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.11</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.83</version>
        </dependency>
    </dependencies>

Enum工具类：


import lombok.extern.slf4j.Slf4j;
import sun.reflect.ConstructorAccessor;
import sun.reflect.FieldAccessor;
import sun.reflect.MethodAccessor;
import sun.reflect.ReflectionFactory;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

@Slf4j
public class EnumUtil {

    /**
     * 扩展枚举（把新枚举的值加入旧枚举里，从旧枚举里删除不要的枚举值）
     * @param oldEnumClass 旧枚举类
     * @param newEnumClass 需要扩展的枚举类
     * @param removeOldEnums 需要删除的旧枚举值
     * @param <O>
     * @param <N>
     * @throws Exception
     */
    public static <O extends Enum,N extends Enum> void extendEnum(Class<O> oldEnumClass,Class<N> newEnumClass,O... removeOldEnums) throws Exception {
        boolean needToRemoveOldEnum = removeOldEnums!=null&&removeOldEnums.length>0;
        if(needToRemoveOldEnum){
            removeEnum(oldEnumClass,removeOldEnums);
        }
        List newEnums = values(newEnumClass);
        Field[] fields = getFields(newEnumClass);
        for (Object newEnumObject : newEnums) {
            Enum newEnum = Enum.class.cast(newEnumObject);

            List<Class> fieldTypeList = new ArrayList<>();
            //枚举名称的类型：String.class
            fieldTypeList.add(String.class);
            for (Field field : fields) {
                fieldTypeList.add(field.getType());
            }
            List<Object> fieldValueList = new ArrayList<>();
            //枚举名称
            fieldValueList.add(newEnum.name());
            for (Field field : fields) {
                Object value = field.get(newEnum);
                fieldValueList.add(value);
            }

            Class[] fieldTypes = fieldTypeList.toArray(new Class[]{});
            String[] fieldValues = fieldValueList.toArray(new String[]{});
            addEnum(oldEnumClass,fieldTypes,fieldValues);
        }
    }

    /**
     * 新增枚举值
     * @param enumClass      枚举类型
     * @param fieldTypes 字段的类型，第一个是枚举名类型String
     * @param fieldValues 字段的值，第一个是枚举名称
     * @throws Exception
     */
    public static <T extends Enum<T>> T addEnum(Class<T> enumClass, Class[] fieldTypes, Object[] fieldValues) throws Exception {
        if(fieldTypes==null||fieldTypes.length==0){
            throw new RuntimeException("参数fieldTypes为空");
        }
        if(fieldValues==null||fieldValues.length==0){
            throw new RuntimeException("参数fieldValues为空");
        }
        if(fieldTypes[0]!=String.class){
            throw new RuntimeException("参数fieldTypes[0]不是String.class");
        }
        if(!(fieldValues[0] instanceof String)){
            throw new RuntimeException("参数fieldValues[0]不是字符串");
        }
        if(fieldTypes.length!=fieldValues.length){
            throw new RuntimeException("参数fieldTypes和参数fieldValues的长度不一致");
        }
        ReflectionFactory reflectionFactory = ReflectionFactory.getReflectionFactory();
        String enumName = fieldValues[0].toString();
        synchronized (enumClass){
            //判断name是否已经添加过了
            if(hasEnumName(enumClass,enumName)){
                log.info("枚举类{}中已存在该枚举名：{}",enumClass.getSimpleName(),enumName);
                return getEnum(enumClass,enumName);
            }
            //name,ordinal,其他自定义字段
            List<Class> allFieldClass = new ArrayList<>(fieldTypes.length + 1);
            allFieldClass.add(String.class);
            allFieldClass.add(int.class);
            for (int i = 1; i < fieldTypes.length; i++) {
                allFieldClass.add(fieldTypes[i]);
            }
            Class[] classes = allFieldClass.toArray(new Class[]{});
            Constructor<T> constructor = enumClass.getDeclaredConstructor(classes);
            ConstructorAccessor constructorAccessor = reflectionFactory.newConstructorAccessor(constructor);
            List<Object> allFields = new ArrayList<>(fieldValues.length + 1);
            allFields.add(enumName);
            int maxOrdinal = getMaxOrdinal(enumClass);
            allFields.add(maxOrdinal+1);
            for (int i = 1; i < fieldValues.length; i++) {
                allFields.add(fieldValues[i]);
            }
            //调用枚举的构造方法，创建新的枚举值
            T newEnum = (T) constructorAccessor.newInstance(allFields.toArray());
            log.info("新增枚举：{}" , newEnum);
            Field valuesField = enumClass.getDeclaredField("$VALUES");
            valuesField.setAccessible(true);

            //解除values属性的final限制
            Field modifiersField = Field.class.getDeclaredField("modifiers");
            modifiersField.setAccessible(true);
            int modifiers = modifiersField.getInt(valuesField);
            modifiers &= ~Modifier.FINAL;
            modifiersField.setInt(valuesField, modifiers);

            //将新增的枚举值加入values属性里
            FieldAccessor fieldAccessor = reflectionFactory.newFieldAccessor(valuesField, false);
            T[] ts = (T[]) fieldAccessor.get(enumClass);
            List<T> list = new ArrayList<>(Arrays.asList(ts));
            list.add(newEnum);
            fieldAccessor.set(enumClass, list.toArray(ts));

            //将Class对象的enumConstants和enumConstantDirectory清空（Enum.valueOf()方法会给它们赋值）
            /**
             * Enum.valueOf()逻辑：
             * 1.取enumConstantDirectory
             *      1.1如果有值则直接返回
             *      1.2如果没值，则取enumConstants，并拷贝到enumConstantDirectory，下次可直接返回
             *          1.2.1如果enumConstants有值，则返回
             *          1.2.2如果enumConstants没值，则取枚举的values属性，并拷贝到enumConstants，下次可直接返回
             * 2.enumConstantDirectory.get(name)返回
             */
            Field enumConstantDirectoryField = enumClass.getClass().getDeclaredField("enumConstantDirectory");
            enumConstantDirectoryField.setAccessible(true);
            FieldAccessor enumConstantDirectoryFieldAccessor = reflectionFactory.newFieldAccessor(enumConstantDirectoryField, false);
            enumConstantDirectoryFieldAccessor.set(enumClass,null);
            Field enumConstantsField = enumClass.getClass().getDeclaredField("enumConstants");
            enumConstantsField.setAccessible(true);
            FieldAccessor enumConstantsFieldAccessor = reflectionFactory.newFieldAccessor(enumConstantsField, false);
            enumConstantsFieldAccessor.set(enumClass,null);
            return newEnum;
        }
    }

    /**
     * 获取枚举类当前最大序号
     * @param enumClass 枚举类型
     * @param <T>
     * @return
     * @throws Exception
     */
    public static <T extends Enum<T>> int getMaxOrdinal(Class<T> enumClass) throws Exception {
        List<T> values = values(enumClass);
        if(values==null||values.size()==0){
            return 0;
        }
        int maxOrdinal = 0;
        for (T value : values) {
            if(maxOrdinal<value.ordinal()){
                maxOrdinal = value.ordinal();
            }
        }
        return maxOrdinal;
    }

    /**
     * 删除枚举值
     * @param enumClass 枚举类型
     * @param removeOldEnums 需要删除的枚举值
     * @param <T>
     */
    public static <T extends Enum<T>> void removeEnum(Class<T> enumClass, Enum<T>... removeOldEnums) throws Exception {
        if(removeOldEnums==null||removeOldEnums.length==0){
            log.warn("removeOldEnums为空");
            return;
        }
        ReflectionFactory reflectionFactory = ReflectionFactory.getReflectionFactory();
        synchronized (enumClass){
            Field valuesField = enumClass.getDeclaredField("$VALUES");
            valuesField.setAccessible(true);

            //解除values属性的final限制
            Field modifiersField = Field.class.getDeclaredField("modifiers");
            modifiersField.setAccessible(true);
            int modifiers = modifiersField.getInt(valuesField);
            modifiers &= ~Modifier.FINAL;
            modifiersField.setInt(valuesField, modifiers);

            FieldAccessor fieldAccessor = reflectionFactory.newFieldAccessor(valuesField, false);
            T[] oldEnumArray = (T[]) fieldAccessor.get(enumClass);
            List<T> enumList = new ArrayList<>(Arrays.asList(oldEnumArray));
            for (Enum removeOldEnum : removeOldEnums) {
                //将指定的枚举值从values属性里删除
                enumList.remove(removeOldEnum);
                log.info("删除枚举值：{}",removeOldEnum);
            }
            //把List转成数组
            T[] newEnumArray = (T[]) Arrays.copyOf(enumList.toArray(), enumList.size(), oldEnumArray.getClass());
            fieldAccessor.set(enumClass, newEnumArray);
        }
    }
	/**
     * 修改枚举属性
     * @param enumClass 枚举类型
     * @param enumName 枚举名称
     * @param attributeName 属性名
     * @param attributeValue 属性值
     * @param <T>
     * @throws Exception
     */
    public static <T extends Enum<T>> void setAttribute(Class<T> enumClass,String enumName,String attributeName,Object attributeValue) throws Exception {
        List<T> values = values(enumClass);
        T target = null;
        for (T t:values){
            if(t.name().equals(enumName)){
                target = t;
                break;
            }
        }
        if(target==null){
            throw new RuntimeException("该枚举类没有枚举名："+enumName);
        }
        Field declaredField = target.getClass().getDeclaredField(attributeName);
        declaredField.setAccessible(true);
        declaredField.set(target,attributeValue);
    }

	/**
     * 修改枚举属性
     * @param targetEnum 枚举值
     * @param attributeName 属性名
     * @param attributeValue 属性值
     * @param <T>
     * @throws Exception
     */
    public static <T extends Enum<T>> void setAttribute(T targetEnum,String attributeName,Object attributeValue) throws Exception {
        Field declaredField = targetEnum.getClass().getDeclaredField(attributeName);
        declaredField.setAccessible(true);
        declaredField.set(targetEnum,attributeValue);
    }

    /**
     * 判断枚举类是否包含了指定枚举名
     * @param clazz
     * @param enumName
     * @param <T>
     * @return
     */
    public static <T extends Enum<T>> boolean hasEnumName(Class<T> clazz, String enumName) throws Exception {
//        不要用valueOf方法，因为它会初始化enumConstantDirectory使得后续调用valueOf方法后拿不到后面加入的枚举值
//        try{
//            T t = Enum.valueOf(clazz, enumName);
//            if(t!=null){
//                return true;
//            }
//        }catch (Exception e){
//            e.printStackTrace();
//            System.err.println(e.getMessage());
//        }
        List<T> values = values(clazz);
        for (T t:values){
            if(t.name().equals(enumName)){
                return true;
            }
        }
        return false;
    }

    /**
     * 根据枚举类型和枚举名获取枚举值
     * @param clazz 枚举类型
     * @param enumName 枚举名称
     * @param <T>
     * @return
     * @throws Exception
     */
    public static <T extends Enum<T>> T getEnum(Class<T> clazz, String enumName) throws Exception {
        List<T> values = values(clazz);
        for (T t:values){
            if(t.name().equals(enumName)){
                return t;
            }
        }
        return null;
    }

    /**
     * 获取枚举类的所有枚举值
     * @param clazz 枚举类型
     * @param <T>
     * @return
     * @throws Exception
     */
    public static <T extends Enum<T>> List<T> values(Class<T> clazz) throws Exception {
        ReflectionFactory reflectionFactory = ReflectionFactory.getReflectionFactory();
        Field valuesField = clazz.getDeclaredField("$VALUES");
        valuesField.setAccessible(true);
        FieldAccessor fieldAccessor = reflectionFactory.newFieldAccessor(valuesField, false);
        T[] ts = (T[]) fieldAccessor.get(clazz);
        List<T> list = new ArrayList<>(Arrays.asList(ts));
        return list;
    }

    /**
     * 获取枚举类的所有枚举值
     * @param clazz 枚举类型
     * @param <T>
     * @return
     * @throws Exception
     */
    public static <T extends Enum<T>> List<T> values2(Class<T> clazz) throws Exception {
        ReflectionFactory reflectionFactory = ReflectionFactory.getReflectionFactory();
        Method valuesMethod = clazz.getDeclaredMethod("values");
        valuesMethod.setAccessible(true);
        MethodAccessor methodAccessor = reflectionFactory.newMethodAccessor(valuesMethod);
        T[] ts = (T[]) methodAccessor.invoke(clazz, null);
        List<T> list = new ArrayList<>(Arrays.asList(ts));
        return list;
    }

    /**
     * 获取枚举的字段（排除数组类型、枚举类型）
     * @param enumClass
     * @return
     */
    public static Field[] getFields(Class<? extends Enum> enumClass){
        List<Field> result = new ArrayList<>();
        Field[] declaredFields = enumClass.getDeclaredFields();
        for (Field field : declaredFields) {
            Class<?> type = field.getType();
            //排除数组类型(values)、枚举类型(枚举值)
            if(type!=enumClass && !type.isArray()){
                field.setAccessible(true);
                result.add(field);
            }
        }
        return result.toArray(new Field[]{});
    }

    /**
     * 打印枚举值
     * @param enumClass 枚举类型
     * @throws Exception
     */
    public static void printEnum(Class<? extends Enum> enumClass) throws Exception {
        System.out.println("+++++++++++++++++++++++");
        List values = values(enumClass);
        values.stream().forEach(System.out::println);
        System.out.println("+++++++++++++++++++++++");
    }

}

有个第三方jar包的User类，User类里有个属性gender，类型是枚举GenderEnum：


import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;

@NoArgsConstructor
@SuperBuilder
@Data
public class User {
    private String username;
    private GenderEnum gender;
}


public enum GenderEnum {
    MAN("man","男"),
    WOMEN("women","女"),
    RENYAO("renyao","人妖"),
    ;
    private String key;
    private String displayName;
    GenderEnum(String key, String  displayName){
        this.key = key;
        this.displayName = displayName;
        System.out.println("调用了GenderEnum枚举构造器创建枚举值："+name());
    }

    @Override
    public String toString() {
        return "GenderEnum{" +
                "ordinal="+ordinal()+
                ", name='"+name()+"'"+
                ", key='" + key + "'"+
                ", displayName='" + displayName + "'" +
                "}";
    }

}

现在项目需要使用User类，但是想去掉“人妖”这个枚举，改成“其他”（无法修改第三方jar包的源码）。
先定义新的枚举类EnhanceGenderEnum：


public enum EnhanceGenderEnum {
    MAN("man","男"),
    WOMEN("women","女"),
    OTHER("other","其他"),
            ;
    private String key;
    private String displayName;
    EnhanceGenderEnum(String key, String  displayName){
        this.key = key;
        this.displayName = displayName;
        System.out.println("调用了EnhanceGenderEnum枚举构造器创建枚举值："+name());
    }

    @Override
    public String toString() {
        return "EnhanceGenderEnum{" +
                "ordinal="+ordinal()+
                ", name='"+name()+"'"+
                ", key='" + key + "'"+
                ", displayName='" + displayName + "'" +
                "}";
    }
}

如此一来，即可对GenderEnum进行增强了（见test()方法）：


import com.alibaba.fastjson.JSON;
import org.junit.Assert;
import org.junit.Test;

import java.lang.reflect.Field;


public class GenderEnumTest {

    @Test
    public void printEnumTest() throws Exception{
        EnumUtil.printEnum(GenderEnum.class);
        EnumUtil.printEnum(EnhanceGenderEnum.class);
    }

    @Test
    public void addEnumTest() throws Exception{
        EnumUtil.printEnum(GenderEnum.class);
        GenderEnum addedEnum = EnumUtil.addEnum(GenderEnum.class, new Class[]{String.class,String.class,String.class}, new Object[]{"OTHER","other","其他"});
        EnumUtil.printEnum(GenderEnum.class);
        boolean addSuccess = false;
        for (GenderEnum value : GenderEnum.values()) {
            if(value==addedEnum){
                addSuccess = true;
            }
        }
        Assert.assertTrue(addSuccess);
        GenderEnum other = GenderEnum.valueOf("OTHER");
        Assert.assertTrue(other!=null&&other==addedEnum);
    }

    @Test
    public void removeTest() throws Exception{
        EnumUtil.printEnum(GenderEnum.class);
        EnumUtil.removeEnum(GenderEnum.class,GenderEnum.RENYAO);
        EnumUtil.printEnum(GenderEnum.class);
        boolean removeSuccess = true;
        for (GenderEnum value : GenderEnum.values()) {
            if(value==GenderEnum.RENYAO){
                removeSuccess = false;
            }
        }
        Assert.assertTrue(removeSuccess);
    }

    @Test
    public void hasEnumNameTest() throws Exception {
        boolean hasEnumName = EnumUtil.hasEnumName(GenderEnum.class, "RENYAO");
        Assert.assertTrue(hasEnumName);
    }

    @Test
    public void getEnumTest() throws Exception {
        GenderEnum anEnum = EnumUtil.getEnum(GenderEnum.class, "RENYAO");
        Assert.assertTrue(anEnum!=null);
    }

    @Test
    public void getFieldsTest(){
        Field[] fields = EnumUtil.getFields(GenderEnum.class);
        for (Field field : fields) {
            System.out.println(field);
        }
    }

    @Test
    public void extendEnumTest() throws Exception{
        EnumUtil.printEnum(GenderEnum.class);
        EnumUtil.extendEnum(GenderEnum.class,EnhanceGenderEnum.class,GenderEnum.RENYAO);
        EnumUtil.printEnum(GenderEnum.class);
    }
    
    @Test
    public void setAttributeTest1() throws Exception {
        System.out.println(GenderEnum.RENYAO);
        EnumUtil.setAttribute(GenderEnum.class,GenderEnum.RENYAO.name(),"displayName","其他");
        System.out.println(GenderEnum.RENYAO);
        EnumUtil.printEnum(GenderEnum.class);
    }
    
    @Test
    public void setAttributeTest2() throws Exception {
        System.out.println(GenderEnum.RENYAO);
        EnumUtil.setAttribute(GenderEnum.RENYAO,"displayName","其他");
        System.out.println(GenderEnum.RENYAO);
        EnumUtil.printEnum(GenderEnum.class);
    }

    @Test
    public void test() throws Exception{
        EnumUtil.extendEnum(GenderEnum.class,EnhanceGenderEnum.class,GenderEnum.RENYAO);
        User user = User.builder().username("sky").gender(GenderEnum.valueOf(EnhanceGenderEnum.OTHER.name())).build();
        String json = JSON.toJSONString(user);
        System.out.println(json);
        User user1 = JSON.parseObject(json, User.class);
        System.out.println(user1.getGender());
    }

}
下一页天空
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java 动态 枚举_java 动态生成枚举值
weixin_34195649的博客
02-18 2861
在某些场景下我们需要动态生成一些枚举值，主要是通过反射生成，但是这种生成枚举值是不能switch的1.枚举值类public enum CodeInfoEnum {LOCK(1L, 1L, "LOCK_TYPE", "LOCK"), UNLOCK(1L, 2L, "LOCK_TYPE", "LOCK");public Long classId;public Long infoId;public St...
Java动态生成枚举类型
qq_35530330的博客
01-02 6150
今天在写项目的时候，遇到一个问题：原本项目中的枚举类型配置类，现在要改成动态配置的方式，即将配置信息，动态写到数据库中，而且用到的配置方式非常复杂。 关键是这个配置是一点文档都没有的。所以找一个方式来代替吧。 于是想到在spring 容器创建的时候，在监听方法中初始化枚举类的内容；其他逻辑都很容易，只有枚举类型动态操作不熟悉，所以留下这篇博客。 import java.lang.reflect.A...
Java程序运行中动态添加枚举
sda1_hacker的博客
11-20 5910
今天在工作中遇到这么一个场景： 调用一个service功能，需要传递枚举，如果传递其他的值还需要修改底层的代码。于是就想到用动态的方式添加枚举。参考了其他人写的例子，自己尝试了一下，说不定之后可以用到，所以在这里纪录一下。 枚举： @Getter public enum Test { PT("服务质量", "bandwidth", "bandwidth", "", "", 1d, false, "带宽", "sum", "服务质量"), private String quota
java 动态添加枚举值_DynamicEnumUtil 动态添加枚举类的枚举值
weixin_39888412的博客
02-16 775
import java.lang.reflect.AccessibleObject;import java.lang.reflect.Array;import java.lang.reflect.Field;import java.lang.reflect.Modifier;import java.util.ArrayList;import java.util.Arrays;import java...
【java】可动态扩展的枚举
最新发布
陌陌龙的博客
08-03 2267
在Java中，枚举（Enum）是一种特殊的类，用于表示一组有限的、预定义的常量集合。枚举在Java语言中是一种基本数据类型，它是通过关键字**enum**来定义的。如下：我们定义了颜色类型的枚举，包含三种颜色// 定义一个颜色枚举类型 enum Color {RED , // 红色 GREEN , // 绿色 BLUE;// 蓝色 }是不是发现很简单。是的枚举的定义就是这么简单。我们现在是思考一个问题，如果我想给这个枚举添加属性该怎么做？比如我们定义一个日期的枚举，需要输出中文的名词，该怎么做？
java 动态生成枚举_动态创建枚举
weixin_39614750的博客
02-19 518
package com.hyh.ucs.dao.entity.enums;import java.lang.reflect.AccessibleObject;import java.lang.reflect.Array;import java.lang.reflect.Field;import java.lang.reflect.Modifier;import java.util.ArrayLis...
Java的枚举类型使用方法详解
09-02
每个枚举值（如SPRING）都是枚举类型的实例，它们默认继承自`java.lang.Enum`类。 2. 特点： - **类型安全**：枚举类型确保只能访问定义在枚举中的值，无法直接创建未定义的新实例，防止了非法值的传递。 - **增强...
Java枚举抽象方法实例解析
08-25
Java 枚举抽象方法实例解析是 Java programming 中一个重要的概念，它允许开发者定义一组固定的常量值，并且每个常量值都有相同的行为，但是具体实现细节不同。使用枚举抽象方法可以使代码结构清晰，易于扩展和维护...
Java枚举类使用场景及实例解析
08-19
* int 表示的枚举值不具有描述性 * int 枚举模式不具有安全性 * String 枚举模式存在一定的性能问题 Java 枚举类是一种非常有用的工具，可以解决许多枚举相关的问题，提高代码的可读性和可维护性。
Jackson优雅序列化Java枚举类过程解析
09-07
接下来，我们可以创建一个实现此接口的枚举，如`GenderEnum`，以存储性别相关的枚举值： ```java public enum GenderEnum implements Enumerator { UNKNOWN(0, "未知"), MALE(1, "男"), FEMALE(2, "女"); ...
java枚举结果类、根据状态值获取枚举值
12-10
java枚举结果类、根据状态值获取枚举值 Controller： /** 模块类型枚举 */ model.addAttribute("mType", ModuleTypeEnum.ModuleTypeShow()); ftl： value="${mType.key}：${mType.value}”
java中的枚举类型详细介绍
09-05
下面将详细阐述Java枚举类型的特性和用法。 1. **枚举定义**： Java中的枚举定义通常以`enum`关键字开始，后面跟着枚举名称，然后是一对大括号，里面列出枚举的各个成员。例如： ```java enum Shrubbery { ...
动态赋值给枚举enum
yuzheh521的博客
02-10 1786
配置类。
动态增加枚举值
qq_30095631的博客
05-12 3138
    之前做东西遇到了这么一个需求，希望动态的增加枚举类中的枚举值。我们正常情况下都是先定义枚举类，然后写好静态的枚举值，然后在代码中使用，那可不可以动态的增加枚举呢？研究后通过反射是可以实现的。工具类如下： package com.huifu.uttf.util.utils; import java.lang.reflect.AccessibleObject; import java.lang.reflect.Array; import java.lang.reflect.Field; import
java 枚举 动态_Java中的动态类加载(枚举)
weixin_35625530的博客
02-12 1047
澄清一下,你的问题不是关于“Java中的动态类加载”,而是关于动态类枚举 – 你知道如何加载类,你只是不知道你想要什么类.从该页面开始,这里有一些应该有效的示例代码：public static Class[] getClasses(String pckgname)throws ClassNotFoundException {ArrayList classes = new ArrayList();/...
java 动态枚举类_运行时动态增加枚举类型
weixin_39781599的博客
02-26 2353
最近在使用一个内部框架的时候，希望能够在运行时指定枚举类型，却发现这是一件挺麻烦的事情(不找别的替代方式，就是要动态增加 enum 的类型)，方法也不正统，不过作为有趣的尝试，研究研究也无妨，下面的内容主要来自于 《Java – create enum instances dynamically》这样一篇文章。在一切开始前，如果你想问，为什么非要增加/改变 enum 类型？其实这是一个非常好的问...
JAVA枚举带赋值
weixin_30437847的博客
09-20 1102
/*媒体类型*/ public enum MediaType { html(0), video(1), audio(2);private final int value; MediaType(int value) { this.value = value; } public int getValue() {...
java 枚举 动态_Java动态修改Enum实例
weixin_39594191的博客
02-12 756
众所周知，enum类型实例数量是固定的，甚至还被用来设计单例。但有时候仍然存在需要动态增加Enum实例的场景，这也并非一定是设计失败，也可能是增加灵活性的实际需求，比如一些web框架，再比如HanLP中的动态用户自定义词性。然而最大的障碍是switch语句生成的虚构类，本文参考Java Specialists第161期，提供一份可用的解决方案与实例代码。一段有问题的代码比如我们有一个enum类...
Java枚举enum的用法
Signal_Du的博客
10-11 795
Java1.5增加了enum类型，使用enum需要注意 1. 创建枚举类型时，必须用enum关键字。所有创建的枚举类型都隐式继承了java.lang.Enum，不可以使用定义一个类继承Enum类的方法来定义枚举类型。 public enum Suit { CLUBS, DIAMONDS, HEARTS, SPADES }2. 上面的代码中构造函数缺省，默认会映射
java 枚举初期赋值
04-20
Java 枚举可以在定义时进行初期赋值，例如： ```java enum Color { RED(255, 0, 0), GREEN(0, 255, 0), BLUE(0, 0, 255); private int r, g, b; Color(int r, int g, int b) { this.r = r; this.g = g; this.b = b; } } ``` 在这个例子中，定义了一个 Color 枚举，其中 RED、GREEN 和 BLUE 分别被赋予了 RGB 值，可以通过构造函数进行赋值。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

下一页天空

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值