精华内容
下载资源
问答
  • 在写状态机框架的时候,在状态枚举类型上面加了注解,当通过 getClass() 得到 Class 对象得到注解时,有些情况得不到注解。发现是自己对 Java 枚举了解不够导致,特记录一下。 定义一个方法 getStateDescField(S s...

    背景

           在写状态机框架的时候,在状态枚举类型上面加了注解,当通过 getClass() 得到 Class 对象得到注解时,有些情况得不到注解。发现是自己对 Java 枚举了解不够导致,特记录一下。

    定义一个方法 getStateDescField(S s) :从注解@StateConfig指定的字段名称,获取传入 s 对应的字段值。

    public static <S> Object getStateDescField(S s) {
            Class clazz = s.getClass();
            if (!clazz.isAnnotationPresent(StateConfig.class)) {
                return null;
            }
            StateConfig stateConfig = (StateConfig) clazz.getAnnotation(StateConfig.class);
            String descField = stateConfig.descField();
            try {
                Field field = clazz.getDeclaredField(descField);
                field.setAccessible(true);
                return field.get(s);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }

      入参 S 传入枚举对象,看一下我们使用的一个状态枚举:

    @StateConfig(descField = "desc")
    public enum OrderStatusEnum {
        CLOSED(-10, "订单关闭"),
        INIT(10, "订单生成"){
            @Override
            public boolean cancelable(Integer openTicketNode) {
                return true;
            }
        },
        PRE_CHECK(15,"待平台预审"){
            @Override
            public boolean cancelable(Integer openTicketNode) {
                return true;
            }
        },
        WAITTING_TO_CHECK(20, "待机构审批"){
            @Override
            public boolean cancelable(Integer openTicketNode) {
                return true;
            }
        },
    
        WAITTING_TO_LOAN(70, "待机构放款"){
            @Override
            public boolean cancelable(Integer openTicketNode) {
                return true;
            }
        },
    
        LOANED(80, "已放款");
    
        private Integer code;
        private String desc;
    
        OrderStatusEnum(Integer code, String desc) {
            this.code = code;
            this.desc = desc;
        }
    
        public boolean cancelable(Integer openTicketNode){
            return false;
        }
    
    }

           最后发现,只有 CLOSED 和 LOANED 两个枚举值成功读出了 desc 描述字段值,其余状态枚举读出的都是 null 。很明显,读不出 desc 字段的枚举值INIT、PRE_CHECK 等都重写了方法 cancelable (Integer openTicketNode),应该就是这里导致出现的问题。

    Debug

    debug 代码发现,CLOSED 枚举进入 getStateDescField(S s) 方法,得到的 Class 对象是OrderStatusEnum:

    但是 INIT 枚举值执行 getStateDescField(S s) 方法,得到的 Class 对象是OrderStatusEnum中的内部类 OrderStatusEnum$1:

    而 OrderStatusEnum$1 上是没有 @StateConfig 的,所以返回了 null。

    结论:

           这就是为什么推荐 枚举类型获取Class对象时,推荐使用 getDeclaringClass() 方法【java.lang.Enum】的原因了:

        /**
         * Returns the Class object corresponding to this enum constant's
         * enum type.  Two enum constants e1 and  e2 are of the
         * same enum type if and only if
         *   e1.getDeclaringClass() == e2.getDeclaringClass().
         * (The value returned by this method may differ from the one returned
         * by the {@link Object#getClass} method for enum constants with
         * constant-specific class bodies.)
         *
         * @return the Class object corresponding to this enum constant's
         *     enum type
         */
        @SuppressWarnings("unchecked")
        public final Class<E> getDeclaringClass() {
            Class<?> clazz = getClass();
            Class<?> zuper = clazz.getSuperclass();
            return (zuper == Enum.class) ? (Class<E>)clazz : (Class<E>)zuper;
        }

           getDeclaringClass() 会先判断上一级 zuper 是不是 Enum.class。我们通过代码测试,可以知道 CLOSED 和 INIT 对应 getClass()和getSuperclass()方法的结果:

        public static void main(String[] args) {
            System.out.println(OrderStatusEnum.CLOSED.getClass());
            System.out.println(OrderStatusEnum.CLOSED.getClass().getSuperclass());
            System.out.println(OrderStatusEnum.INIT.getClass());
            System.out.println(OrderStatusEnum.INIT.getClass().getSuperclass());
            System.out.println(OrderStatusEnum.INIT.getClass().getSuperclass().getSuperclass());
        }

    输出结果:

    class OrderStatusEnum
    class java.lang.Enum
    class OrderStatusEnum$1
    class OrderStatusEnum
    class java.lang.Enum

          可以看到,实现了方法的枚举值INIT需要调用两次 getSuperclass() 方法才能得到 java.lang.Enum 的Class对象,调用一次 getSuperclass() 方法刚好可以得到OrderStatusEnum的Class 对象。而 CLOSED 枚举值直接getClass()就得到OrderStatusEnum的Class 对象。所以 getDeclaringClass() 方法能确保 INIT 和CLOSED 获取到的都是 OrderStatusEnum的Class 对象。

           另外我们通过命令编译 javac OrderStatusEnum.java,确实可以看到 INIT、PRE_CHECK、WAITTING_TO_CHECK、WAITTING_TO_LOAN 被编译成了四个内部类:

    使用 javap -c 命令可以看到 OrderStatusEnum 继承了 Enum 类:

           INIT 等继承覆盖了 OrderStatusEnum 中的 cancelable 方法,而且上面 INIT.getClass().getSuperClass 为 OrderStatusEnum ,所以 INIT 对应的 OrderStatusEnum$1 应该继承了 OrderStatusEnum,但是一时不知道怎么反编译 OrderStatusEnum$1查看验证,麻烦有知道的告诉一下哈~

    展开全文
  • 本文主要介绍了枚举类型的有关内容,涉及简单的枚举类型定义,以及枚举类型的值在Java中的定义方法,具有一定参考价值,需要的朋友可以了解下。
  • 自定义枚举类 public class TestEnum1 { public static void main(String[] args) { Person man = Person.MAN; System.out.println(man.toString()); Person woman = Person.WOMAN; System.out....
    1. 自定义枚举类
      public class TestEnum1 {
      	public static void main(String[] args) {
      		
      		Person man = Person.MAN;
      		System.out.println(man.toString());
      		Person woman = Person.WOMAN;
      		System.out.println(woman);
      	}
      }
      //自定义枚举类型
      class Person{
      	//1 属性私有化
      	private final String name;
      	private final int age;
      	//2 构造器私有 化
      	private Person(String name,int age) {
      		this.name = name;
      		this.age = age;
      	}
      	//3 创建对象 
      	public final static Person MAN = new Person("小明",20);
      	public final static Person WOMAN = new Person("小花",23);
      	@Override
      	public String toString() {
      		return "Person [name=" + name + ", age=" + age + "]";
      	}
      }
      

       

    2. 通过enum关键字定义枚举
      public class TestEnum2 {
      	public static void main(String[] args) {
      		Person1 man = Person1.MAN;
      		System.out.println(man.info());
      		Person1 woman = Person1.WOMAN;
      		System.out.println(woman.info());
      	}
      }
      enum Person1{
      	MAN("小明",20),
      	WOMAN("小花",24);
      	//1 属性私有化
      	private final String name;
      	private final int age;
      	//2 构造器私有 化
      	
      	private Person1(String name,int age) {
      		this.name = name;
      		this.age = age;
      	}
      	public String info() {
      		return "Person1 [name=" + name + ", age=" + age + "]";
      	}
      }
      

      注意:创建对象必须放在最枚举类的最前面

    3. 如何实现接口
      interface Interface1{
      	void show();
      }
      enum Person1 implements Interface1{
      	MAN("小明",20){
      		public void show() {
      			System.out.println("男人");
      		}
      	},
      	WOMAN("小花",24){
      		public void show() {
      			System.out.println("女人");
      		}
      	};
      	//1 属性私有化
      	private final String name;
      	private final int age;
      	//2 构造器私有 化
      	
      	private Person1(String name,int age) {
      		this.name = name;
      		this.age = age;
      	}
      	public String info() {
      		return "Person1 [name=" + name + ", age=" + age + "]";
      	}
      	@Override
      	public void show() {
      		System.out.println("这是人类");
      		
      	}
      }
      

       

    4. 枚举中方法使用
      //两个常用的方法 values()  valueOf(String)
      		//values()获取枚举类中的所有对象 
      		Person1[] ps = Person1.values();
      		for(Person1 p : ps) {
      			System.out.println(p.info());
      		}
      		System.out.println("=============");
      		//valueOf(对象字符串)获取其中一个
      		Person1 p1 = Person1.valueOf("MAN");
      		System.out.println(p1.info());
      		Person1 p2 = Person1.valueOf("WOMAN");
      		System.out.println(p2.info());
      

       

    展开全文
  • Java枚举

    千次阅读 2017-05-03 09:23:36
    Java之枚举 枚举定义 枚举与全局常量的区别 枚举特性,获取枚举对象的方法 枚举实例

    1.定义

    enum 是一种数据类型,与 全局常量比较相似,都是全局的并且是可以通过类名调用的
    

    与全局常量区别

        枚举功能更强大,可以有属性和方法
        枚举比全局常量更加的规范
    

    2.枚举特性

    1)可以有属性以及set/get,方法,构造函数
    
    2)可以与switch连用
    
    3)可以重写toString方法,打印枚举对象时也会默认调用(官方不提供自动重写该方法)
    
    4)可以实现接口
    

    3.获取枚举对象方法

    【返回枚举属性值对应的对象】枚举.valueof(“属性值”)
    【返回所有枚举属性值对应的对象】枚举.values()
    【返回枚举对象】枚举.属性
    

    4.枚举实例

    代码:

    枚举类

    package com.qf.demo7;
    
    public enum Color {
        // red,green,yellow,实际上是Color枚举类型对象
        RED("红色",1),GREEN("绿色",2),YELLOW("黄色",3);
    
        // 无论是否创建枚举对象   都一定需要加上 分号  否则编译报错
    
        //枚举类可以添加属性和方法,如下
        String name;
        int id;
    
        private Color(String name, int id) {
            this.name = name;
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getId() {
            return id;
        }
        public void setId(int id) {
            this.id = id;
        }
        // 枚举中可以重写 toString 但是官方不会提供  
        // 打印对象时,会帮助自动调用
        @Override
        public String toString() {
            // TODO Auto-generated method stub
            return "id="+id+",name="+name;
        }
    }
    

    测试类:

    package com.qf.demo7;
    
    public class Test {
    
        public static void main(String[] args) {
            //1.获取枚举对象:类.属性
            Color color= Color.YELLOW;// 
            System.out.println(color.getName()+" "+color.getId());
    
            //2.获取枚举对象:类.valueOf()
            Color color2 = Color.valueOf("RED");// 根据枚举属性值 得到 枚举对象
    
            //3.获取所有属性值:类.values()
            Color[] colors = Color.values();// 得到枚举中所有的属性对应的对象
            for (Color color3 : colors) {
                System.out.println(color3);
            }
    
    
            //4.枚举可以作为switch语句的表达式
            switch (color2) {
            case RED:
                System.out.println("红色");
                break;
            case GREEN:
                System.out.println("绿色");
                break;
            case YELLOW:
                System.out.println("黄色");
                break;
            }
        }
    }
    
    展开全文
  • Java 枚举(enum) 详解7种常见的用法

    万次阅读 多人点赞 2016-08-11 11:14:45
    JDK1.5引入了新的类型——枚举。...在JDK1.5之前,我们定义常量都是:public static final....。现在好了,有了枚举,可以把相关的常量分组到一个枚举类型里,而且枚举提供了比常量更多的方法。 Java代码 publ...

    JDK1.5引入了新的类型——枚举。在 Java 中它虽然算个“小”功能,却给我的开发带来了“大”方便。

    大师兄我【大师兄】又加上自己的理解,来帮助各位理解一下。

    用法一:常量

    在JDK1.5 之前,我们定义常量都是: public static final.... 。现在好了,有了枚举,可以把相关的常量分组到一个枚举类型里,而且枚举提供了比常量更多的方法。 

    Java代码 

    public enum Color {  
      RED, GREEN, BLANK, YELLOW  
    } 

    用法二:switch

    JDK1.6之前的switch语句只支持int,char,enum类型,使用枚举,能让我们的代码可读性更强。 

    Java代码 

    enum Signal {  
        GREEN, YELLOW, RED  
    }  
    public class TrafficLight {  
        Signal color = Signal.RED;  
        public void change() {  
            switch (color) {  
            case RED:  
                color = Signal.GREEN;  
                break;  
            case YELLOW:  
                color = Signal.RED;  
                break;  
            case GREEN:  
                color = Signal.YELLOW;  
                break;  
            }  
        }  
    }  

    用法三:向枚举中添加新方法

    如果打算自定义自己的方法,那么必须在enum实例序列的最后添加一个分号。

    https://blog.csdn.net/qq_27093465/article/details/52180865

    而且 Java 要求必须先定义 enum 实例。 

    Java代码 

    public enum Color {  
        RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
        // 成员变量  
        private String name;  
        private int index;  
        // 构造方法  
        private Color(String name, int index) {  
            this.name = name;  
            this.index = index;  
        }  
        // 普通方法  
        public static String getName(int index) {  
            for (Color c : Color.values()) {  
                if (c.getIndex() == index) {  
                    return c.name;  
                }  
            }  
            return null;  
        }  
        // get set 方法  
        public String getName() {  
            return name;  
        }  
        public void setName(String name) {  
            this.name = name;  
        }  
        public int getIndex() {  
            return index;  
        }  
        public void setIndex(int index) {  
            this.index = index;  
        }  
    }  

    用法四:覆盖枚举的方法

    下面给出一个toString()方法覆盖的例子。 

    Java代码 

    public enum Color {  
        RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
        // 成员变量  
        private String name;  
        private int index;  
        // 构造方法  
        private Color(String name, int index) {  
            this.name = name;  
            this.index = index;  
        }  
        //覆盖方法  
        @Override  
        public String toString() {  
            return this.index+"_"+this.name;  
        }  
    }  

    用法五:实现接口

    所有的枚举都继承自java.lang.Enum类。由于Java 不支持多继承,所以枚举对象不能再继承其他类。 

    Java代码 

    public interface Behaviour {  
        void print();  
        String getInfo();  
    }  
    public enum Color implements Behaviour{  
        RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
        // 成员变量  
        private String name;  
        private int index;  
        // 构造方法  
        private Color(String name, int index) {  
            this.name = name;  
            this.index = index;  
        }  
    //接口方法  
        @Override  
        public String getInfo() {  
            return this.name;  
        }  
        //接口方法  
        @Override  
        public void print() {  
            System.out.println(this.index+":"+this.name);  
        }  
    }  

    用法六:使用接口组织枚举

     Java代码 

    public interface Food {  
        enum Coffee implements Food{  
            BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO  
        }  
        enum Dessert implements Food{  
            FRUIT, CAKE, GELATO  
        }  
    }  
        /**
         * 测试继承接口的枚举的使用(by 大师兄 or 大湿胸。)
         */
        private static void testImplementsInterface() {
            for (Food.DessertEnum dessertEnum : Food.DessertEnum.values()) {
                System.out.print(dessertEnum + "  ");
            }
            System.out.println();
            //我这地方这么写,是因为我在自己测试的时候,把这个coffee单独到一个文件去实现那个food接口,而不是在那个接口的内部。
            for (CoffeeEnum coffee : CoffeeEnum.values()) {
                System.out.print(coffee + "  ");
            }
            System.out.println();
            //搞个实现接口,来组织枚举,简单讲,就是分类吧。如果大量使用枚举的话,这么干,在写代码的时候,就很方便调用啦。
            //还有就是个“多态”的功能吧,
            Food food = Food.DessertEnum.CAKE;
            System.out.println(food);
            food = CoffeeEnum.BLACK_COFFEE;
            System.out.println(food);
        }

    运行结果

    用法七:关于枚举集合的使用

    java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复;EnumMap中的 key是enum类型,而value则可以是任意类型。关于这个两个集合的使用就不在这里赘述,可以参考JDK文档。

    关于枚举的实现细节和原理请参考:

    参考资料:《ThinkingInJava》第四版

    http://softbeta.iteye.com/blog/1185573

     

    我的这篇文章,因为是转载的,可能基本就没有变动,导致被某人踩了一脚。觉得不符合我大师兄的性格。下面我把自己的使用理解给整理一下。

     

    也是因为因为当时刚刚开始学习吧。把平时自以为了解的东西都只是大概了解了一下,说到底,还是自以为了解了,其实转眼就不知道什么是什么了。
    出来学习,不习惯看代码怎么能行呢?
    下面是我自己的测试代码。

    package com.lxk.enumTest;
    
    /**
     * Java枚举用法测试
     * <p>
     * Created by lxk on 2016/12/15
     */
    public class EnumTest {
        public static void main(String[] args) {
            forEnum();
            useEnumInJava();
        }
    
        /**
         * 循环枚举,输出ordinal属性;若枚举有内部属性,则也输出。(说的就是我定义的TYPE类型的枚举的typeName属性)
         */
        private static void forEnum() {
            for (SimpleEnum simpleEnum : SimpleEnum.values()) {
                System.out.println(simpleEnum + "  ordinal  " + simpleEnum.ordinal());
            }
            System.out.println("------------------");
            for (TYPE type : TYPE.values()) {
                System.out.println("type = " + type + "    type.name = " + type.name() + "   typeName = " + type.getTypeName() + "   ordinal = " + type.ordinal());
            }
        }
    
        /**
         * 在Java代码使用枚举
         */
        private static void useEnumInJava() {
            String typeName = "f5";
            TYPE type = TYPE.fromTypeName(typeName);
            if (TYPE.BALANCE.equals(type)) {
                System.out.println("根据字符串获得的枚举类型实例跟枚举常量一致");
            } else {
                System.out.println("大师兄代码错误");
            }
    
        }
    
        /**
         * 季节枚举(不带参数的枚举常量)这个是最简单的枚举使用实例
         * Ordinal 属性,对应的就是排列顺序,从0开始。
         */
        private enum SimpleEnum {
            SPRING,
            SUMMER,
            AUTUMN,
            WINTER
        }
    
    
        /**
         * 常用类型(带参数的枚举常量,这个只是在书上不常见,实际使用还是很多的,看懂这个,使用就不是问题啦。)
         */
        private enum TYPE {
            FIREWALL("firewall"),
            SECRET("secretMac"),
            BALANCE("f5");
    
            private String typeName;
    
            TYPE(String typeName) {
                this.typeName = typeName;
            }
    
            /**
             * 根据类型的名称,返回类型的枚举实例。
             *
             * @param typeName 类型名称
             */
            public static TYPE fromTypeName(String typeName) {
                for (TYPE type : TYPE.values()) {
                    if (type.getTypeName().equals(typeName)) {
                        return type;
                    }
                }
                return null;
            }
    
            public String getTypeName() {
                return this.typeName;
            }
        }
    }
    

    然后是测试的结果图:

    简单的例子,大家基本都用过,看不懂的基本都是第二个例子。可以看到,在第二个例子里面,后面带有参数,其实可以这么理解。

    enum这个关键字,可以理解为跟class差不多,这也个单独的类。可以看到,上面的例子里面有属性,有构造方法,有getter,也可以有setter,但是一般都是构造传参数。还有其他自定义方法。那么在这些东西前面的,以逗号隔开的,最后以分号结尾的,这部分叫做,这个枚举的实例。也可以理解为,class  new 出来的实例对象。这下就好理解了。只是,class,new对象,可以自己随便new,想几个就几个,而这个enum关键字,他就不行,他的实例对象,只能在这个enum里面体现。也就是说,他对应的实例是有限的。这也就是枚举的好处了,限制了某些东西的范围,举个栗子:一年四季,只能有春夏秋冬,你要是字符串表示的话,那就海了去了,但是,要用枚举类型的话,你在enum的大括号里面把所有的选项,全列出来,那么这个季节的属性,对应的值,只能在里面挑。不能有其他的。

    我上面的例子,就是根据typeName,你可以从那些例子里面挑选到唯一的一个TYPE类型的枚举实例--TYPE.BALANCE。注意方法

    TYPE type = TYPE.fromTypeName(typeName);
    这个方法的返回类型就是这个TYPE枚举类型的。
    这下就好理解,这个枚举是怎么在工作了吧

    再补充一下:

    上面那个带参数的枚举类型的实例里面实际上是三个属性,除了我自定义的typeName以外,还有2个是系统自带的。看下面源码的图:

    看到这里之后,不知道你能不能理解下面图片内说明的话:下面图片主要说明在使用枚举时,的规范和标准。希望可以在实际开发时候用到

    最后补充一点:

    也许你知道呢,但是也许你不知道呢?我是真的不知道,测了之后才知道!!!

    枚举类型对象之间的值比较,是可以使用==,直接来比较值,是否相等的,不是必须使用equals方法的哟。

    具体,请参考下面的链接:

    java 枚举类比较是用==还是equals?

    2017.11.07 更新

    有的老铁,说这个switch case怎么写,我就在下面再啰嗦一下。

        private static void testSwitchCase() {
            String typeName = "f5";
            //这几行注释呢,你可以试着三选一,测试一下效果。
            //String typeName = "firewall";
            //String typeName = "secretMac";
            TypeEnum typeEnum = TypeEnum.fromTypeName(typeName);
            if (typeEnum == null) {
                return;
            }
            switch (typeEnum) {
                case FIREWALL:
                    System.out.println("枚举名称(即默认自带的属性 name 的值)是:" + typeEnum.name());
                    System.out.println("排序值(默认自带的属性 ordinal 的值)是:" + typeEnum.ordinal());
                    System.out.println("枚举的自定义属性 typeName 的值是:" + typeEnum.getTypeName());
                    break;
                case SECRET:
                    System.out.println("枚举名称(即默认自带的属性 name 的值)是:" + typeEnum.name());
                    System.out.println("排序值(默认自带的属性 ordinal 的值)是:" + typeEnum.ordinal());
                    System.out.println("枚举的自定义属性 typeName 的值是:" + typeEnum.getTypeName());
                    break;
                case BALANCE:
                    System.out.println("枚举名称(即默认自带的属性 name 的值)是:" + typeEnum.name());
                    System.out.println("排序值(默认自带的属性 ordinal 的值)是:" + typeEnum.ordinal());
                    System.out.println("枚举的自定义属性 typeName 的值是:" + typeEnum.getTypeName());
                    break;
                default:
                    System.out.println("default");
            }
        }
    

    然后,就是运行结果的截图。

    老铁们,看完这个枚举,你要懂个概念,那就是,这个枚举,他是个对象,就像你定义的Student类,Person类,等等一些个类一样。

    要有这么个概念。只要是个类,他就可以有构造函数,可以有属性,可以有方法。

    对的,老铁,你对这个属性,构造函数啥的,有概念吧,没有的话,我可就郁闷啦。

    然后,你就看到,这个地方有2个默认的属性,一个是name,一个是ordinal,这2个属性就像你定义Student类和Person类的name和age一样,

    只不过,这2个是系统自带的属性,不用你自己去定义啦。

    你也可以给这个枚举类,也就是你自己声明的枚举,随便加属性。

    我上面代码例子里面的那个TypeEnum那个枚举,就是这么干的,就简单的添加了个自定义属性typeName,

    虽然他有自己的name了,那姑且叫我这个自定义的属性叫别名吧。

    可以看到,我例子里面就是通过自己写的那个构造方法给我这个自定义的属性初始化值的。

    还有,这个构造方法是不可以,也不被运行public的,不信,你可以试试。

    还有,你不能对系统自带的name属性,在构造函数里面赋值,没有为什么。

    https://blog.csdn.net/qq_27093465/article/details/52180865

    (2019-07-29更新)

    再补充一点,这个也比较重要

    就是这个枚举类型,一旦创建,且被使用(比如,存数据库啥的)之后,持久化后的对象信息里面就保存了这个枚举信息。这个时候你的需求或者要求啥的,需要变更这个枚举名称。应当禁止这个变更的操作,只能重新创建,用新的代替旧的,不能直接把旧的给改了,因为,就数据在逆转成对象的时候,如果,旧的枚举不在了,那么就会400还是500的报错或者是空指针的bug。这也是需要关注的一个问题。希望注意下,不然等到出bug了再想到这个问题,就不好了。

     

    我写完文章,给自己点个赞,不过分吧,
    不过分,那我可就点啦啊。
    我先点为敬,你们随意。大家随意。不要客气。。。

    展开全文
  • 文章目录枚举类的定义jdk5.0之前定义枚举类jdk5.0之后定义枚举类使用enum关键字定义枚举类使用enum关键字定义的枚举类实现接口 枚举类的定义 关于枚举类 1 枚举类的理解:类的对象只有有限个,确定的。我们称此类为...
  • 定义枚举 public enum NodeType { /** * 节点类型枚举 */ USER_TASK("userTask", "用户审批节点", UserTask.class); public String type; public String name; public Class<?> clazz; public ...
  • java通过反射获取枚举对象

    万次阅读 2017-10-20 13:51:25
    里面使用到的枚举对象也随之增加,以往是每个枚举都有一个获取的方法,后来网上查了一下.可以通过java的反射机制来获取代码如下 Class<?> onwClass = Class.forName(...
  • 当类的对象时有限且固定的,如季节类,它只有春夏秋冬4个对象这种实例有限且固定的类,在 Java 中被称为枚举类; 定义: public enum ElementType { NODE, EDGE } 这是java中的语法糖实际上会被编译成这样: ...
  • * 下拉选项返回模型对象 created by tely on 2015/06/15. */ @Data public class SelectBean implements Serializable { private String key; private String value; private List subObj; } package com.ig
  • java反射之获取枚举对象

    千次阅读 2018-05-16 11:25:08
    java反射之获取枚举对象项目中导入大量枚举对象,用来定义常量。随着带来一个问题,就是每个枚举类都需要通过key来获取对应枚举的需求。 1 public enum ExamType { 2 CRAFT(1, "草稿"), 3 PASSING(2, &...
  • 讲真,java枚举类提供的方法太少了,Enum只有两个valueOf可以搞,如果碰上需要传入枚举类型的值,获取枚举对象或者枚举类型名称的时候,只能干瞪眼,或者循环比对。最近项目就遇到这种,而且感觉以后以及别人都...
  • 深入理解Java枚举类型(enum)

    万次阅读 多人点赞 2017-05-13 18:27:14
    【版权申明】未经博主同意,谢绝转载!(请尊重原创,博主保留追究权) ...深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深入理解
  • 讲真,java枚举类提供的方法太少了,Enum只有两个valueOf可以搞,如果碰上需要传入枚举类型的值,获取枚举对象或者枚举类型名称的时候,只能干瞪眼,或者循环比对。最近项目就遇到这种,而且感觉以后以及别人都...
  • 枚举类型常用于定义常量类型优势:·类型安全·紧凑有效的数据定义·可与其他程序交互·运行效率高一般以内部类形式存在,枚举类型的构造方法一般以private修饰。通俗定义方法:public enum 类名{ 常量名.... }...
  • Java必备之面向对象-枚举定义与使用详解.pdf
  • java-枚举

    2019-03-21 15:29:07
    java-枚举 1.首先java中的枚举结构实际上是一个...枚举对象定义在结构的首行; 3.枚举其实就是一个多例模式,所以要理解枚举,先要看一个多例模式 class Season{ private static Season Spring=new Season("春")...
  • Java定义一个枚举类型

    千次阅读 2020-02-18 23:16:50
    Java 有两种方式定义新类型:类和接口。对于大部分面向对象编程来说,这两种方法够了,但是对于一些特殊情况比如:想定义一个 Color 类,它只能有 ...可以使用关键字 enum 定义枚举类型: [public] enum 枚举类型{ ...
  • Java枚举

    2015-10-06 10:00:24
    定义枚举创建枚举需要用enum关键字。下面的代码创建了一个名叫Colors的枚举,包含几个颜色。public enum Colors { Red, Yellow, Blue, Black, White }使用枚举//声明枚举对象的方式 Colors c
  • Java枚举详解

    万次阅读 多人点赞 2019-05-12 23:07:44
    类似这种当一个变量有几种固定可能的取值时,就可以将它定义枚举类型。 在 JDK 1.5 之前没有枚举类型,那时候一般用接口常量来替代。而使用 Java 枚举类型 enum 可以更贴近地表示这种常量。 声明枚举 声明枚举时...
  • 枚举定义 package com.scbd.bdpl.define.enumerate.code; import com.java.comn.assist.EnumDefine; import com.scbd.bdpl.support.annotation.AnnotationCodeType; /** * @author lp */ public enum STR ...
  • Java1.5提供了关键字enum,能够通过该关键字方便得定义自己须要的枚举类型,比方  enum Season {  SPRING, SUMMER, AUTUMN, WINTER  }  定义了一个季节枚举类型。  在本例中,对于Season.SPRING这个...
  • Java Enum 枚举

    千次阅读 2011-02-10 10:39:00
    Java Enum 枚举
  • Java枚举类的定义以及使用

    万次阅读 2013-10-17 23:10:06
    那是因为,一些方法在运行时,它需要的数据不能是任意的,而必须是一定范围内的值,此类问题在JDK5以前采用自定义带有枚举功能的类解决,Java5以后可以直接使用枚举予以解决。  举个简单的例子,我们每个人都有...
  • java枚举类的定义和使用

    万次阅读 热门讨论 2018-08-11 12:28:24
    对象个数 一个可以看做单例模式的实现 多个 为枚举类 1 如何定义  cccccccc  1 私有化类的构造器。  2 成员变量如果声明为final。要在构造器中初始化,不允许被修改、 3 通过公共方法 调用属性...
  • JAVA_枚举

    2016-06-15 15:34:01
     创建枚举类型要使用 enum 关键字,隐含了所创建的类型都是 java.lang.Enum 类的子类(java.lang.Enum 是一个抽象类)。枚举类型符合通用模式 Class Enum>,而 E 表示枚举类型的名称。枚举类型的每一个值都将映射到...
  • 枚举是从Java5开始提供的一种新的数据类型,是一个特殊的类,就是固定的多个常量对象定义格式:[修饰符] enum 枚举类名 { 常量A,常量B,常量C; }我们自定义的枚举类型,在编译后(底层),都是直接继承于java.lang....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 117,846
精华内容 47,138
关键字:

java定义枚举对象

java 订阅