【转载】Java枚举类型的使用

枚举类型概念

[java] view plain copy

  1. package com.lxq.enumm;
  2. public class EnumDemoOne
  3. {
  4. private enum InnerEnum
  5. {
  6. RED, GREEN, YELLOW
  7. };
  8. public static void main(String[] args)
  9. {
  10. System.out.println(InnerEnum.RED);
  11. System.out.println(InnerEnum.GREEN);
  12. System.out.println(InnerEnum.YELLOW);
  13. }
  14. }

运行上面的代码，将编辑产生EnumDemoOne.class和EnumDemoOne$InnerEnum.class。

由此说明定义枚举类型其实就是在定义一个类，只不过很多细节由编译器帮你补齐了，所以，某种程度上enum关键词的作用就像是class或interface.当使用enum定义枚举类型时，实际上所定义出来的类型是继承自java.lang.Enum类。而每个被枚举的成员其实就是定义的枚举类型的一个实例，它们都被默认为final。无法改变常数名称所设定的值，它们也是public和static的成员，这与接口中的常量限制相同。可以通过类名称直接使用它们。

Java枚举类型的案例一

[java] view plain copy

  1. package com.lxq.enumm;
  2. public class EnumDemoTwo
  3. {
  4. public enum ColorSelect
  5. {
  6. red, green, yellow, blue;
  7. }
  8. public static void main(String[] args)
  9. {
  10. /*
  11. * 枚举类型是一种类型，用于定义变量，以限制变量的赋值 赋值时通过"枚举名.值"来取得相关枚举中的值
  12. */
  13. ColorSelect m = ColorSelect.blue;
  14. switch (m)
  15. {
  16. /*注意:枚举重写了ToString(),说以枚举变量的值是不带前缀的
  17. * 所以为blue而非ColorSelect.blue
  18. */
  19. case red:
  20. System.out.println("color is red");
  21. break;
  22. case green:
  23. System.out.println("color is green");
  24. break;
  25. case yellow:
  26. System.out.println("color is yellow");
  27. break;
  28. case blue:
  29. System.out.println("color is blue");
  30. break;
  31. }
  32. System.out.println("遍历ColorSelect中的值");
  33. /*通过values()获得枚举值的数组*/
  34. for (ColorSelect c : ColorSelect.values())
  35. {
  36. System.out.println(c);
  37. }
  38. System.out.println("枚举ColorSelect中的值有："+ColorSelect.values().length+"个");
  39. /*ordinal()返回枚举值在枚举中的索引位置，从0开始*/
  40. System.out.println(ColorSelect.red.ordinal());//0
  41. System.out.println(ColorSelect.green.ordinal());//1
  42. /*name()返回枚举值在枚举中的索引位置，从0开始*/
  43. System.out.println(ColorSelect.yellow.name());//yellow
  44. System.out.println(ColorSelect.blue.name());//blue
  45. /*枚举默认实现了java.lang.Comparable接口,-1之前，0位置相同，1之后*/
  46. System.out.println(ColorSelect.red.compareTo(ColorSelect.green));
  47. /*静态valueOf()方法可以让您将指定的字符串尝试转换为枚举类型*/
  48. ColorSelect red=ColorSelect.valueOf("red");
  49. System.out.println(red.getClass());
  50. }
  51. }

Java枚举类型的案例二

上面案例一的枚举类型的返回值仅仅是该枚举变量的名称而已，我们当然也可以通过参数自己制定更加友好更加形象的枚举类型的返回值。

下面的代码简单来说，就箱单我们有一个类，类中有构造方法和变量clor，那么我们通过new Light("颜色");就可以新建一个类的实例，其实枚举就是这个意思，

RED ("红色"), GREEN ("绿色"), YELLOW ("黄色");这三个就当然于实例化了三个对象。也就是Light RED=new Light("红色"); Light GREEN=new Light("绿色");

Light YELLOW=new Light("黄色");只不过定义了枚举类型后，剩下的工作由java编译器帮我们完成了。

[java] view plain copy

  1. package com.lxq.enumm;
  2. import java.util.EnumMap;
  3. import java.util.EnumSet;
  4. public class EnumDemoThree{
  5. // 1. 定义枚举类型
  6. public enum Light {
  7. /*利用构造函数传参利用构造函数传参
  8. * 通过括号赋值,而且必须有带参构造器和属性和方法，否则编译出错
  9. * 赋值必须是都赋值或都不赋值，不能一部分赋值一部分不赋值
  10. * 如果不赋值则不能写构造器，赋值编译也出错
  11. * */
  12. RED ("红色"), GREEN ("绿色"), YELLOW ("黄色");
  13. // 定义私有变量
  14. private String clor ;
  15. // 构造函数，枚举类型只能为私有
  16. private Light(String clor) {
  17. this.clor = clor;
  18. }
  19. public String getClor(){
  20. return this.clor;
  21. }
  22. public void setClor(String clor){
  23. this.clor=clor;
  24. }
  25. @Override
  26. public String toString() {
  27. return this.clor;
  28. }
  29. }
  30. /**
  31. * @param args
  32. */
  33. public static void main(String[] args ) {
  34. // 1. 遍历枚举类型
  35. System.out.println( " 演示枚举类型的遍历 ......" );
  36. testTraversalEnum ();
  37. // 2. 演示 EnumMap 对象的使用
  38. System. out .println( " 演示 EnmuMap 对象的使用和遍历 ....." );
  39. testEnumMap ();
  40. // 3. 演示 EnmuSet 的使用
  41. System. out .println( " 演示 EnmuSet 对象的使用和遍历 ....." );
  42. testEnumSet ();
  43. }
  44. /**
  45. * 演示枚举类型的遍历
  46. */
  47. private static void testTraversalEnum() {
  48. Light[] allLight = Light.values ();
  49. for (Light aLight : allLight) {
  50. System. out .println( " 当前灯 name ： " + aLight.name());
  51. System. out .println( " 当前灯 ordinal ： " + aLight.ordinal());
  52. System. out .println( " 当前灯： " + aLight);
  53. }
  54. }
  55. /**
  56. * 演示 EnumMap 的使用， EnumMap 跟 HashMap 的使用差不多，只不过 key 要是枚举类型
  57. */
  58. private static void testEnumMap() {
  59. // 1. 演示定义 EnumMap 对象， EnumMap 对象的构造函数需要参数传入 , 默认是 key 的类的类型
  60. EnumMap<Light, String> currEnumMap = new EnumMap<Light, String>(
  61. Light. class );
  62. currEnumMap.put(Light. RED , " 红灯 " );
  63. currEnumMap.put(Light. GREEN , " 绿灯 " );
  64. currEnumMap.put(Light. YELLOW , " 黄灯 " );
  65. // 2. 遍历对象
  66. for (Light aLight : Light.values ()) {
  67. System. out .println( "[key=" + aLight.name() + ",value="
  68. + currEnumMap.get(aLight) + "]" );
  69. }
  70. }
  71. /**
  72. * 演示 EnumSet 如何使用， EnumSet 是一个抽象类，获取一个类型的枚举类型内容 <BR/>
  73. * 可以使用 allOf 方法
  74. */
  75. private static void testEnumSet() {
  76. EnumSet<Light> currEnumSet = EnumSet.allOf (Light. class );
  77. for (Light aLightSetElement : currEnumSet) {
  78. System. out .println( " 当前 EnumSet 中数据为： " + aLightSetElement);
  79. }
  80. }
  81. }

Java枚举类型的案例三

案例三在二的基础上增加了构造时的参数个数，使得这样的枚举有更广泛的用处。

[java] view plain copy

  1. package com.lxq.enumm;
  2. public enum EnumConstant
  3. {
  4. WEEK_00("", "请选择"),WEEK_01("01", "周一"), WEEK_02("02", "周二"), WEEK_03("03", "周三");
  5. private String key;
  6. private String value;
  7. //自定义的构造函数，参数数量，名字随便自己取
  8. //构造器默认也只能是private, 从而保证构造函数只能在内部使用
  9. private EnumConstant(String key, String value)
  10. {
  11. this.key = key;
  12. this.value = value;
  13. }
  14. public String getKey()
  15. {
  16. return key;
  17. }
  18. public void setKey(String key)
  19. {
  20. this.key = key;
  21. }
  22. public String getValue()
  23. {
  24. return value;
  25. }
  26. public void setValue(String value)
  27. {
  28. this.value = value;
  29. }
  30. //重新toString方法，默认的toString方法返回的就是枚举变量的名字，和name()方法返回值一样
  31. @Override
  32. public String toString()
  33. {
  34. return this.key+":"+this.value;
  35. }
  36. }

[java] view plain copy

  1. package com.lxq.enumm;
  2. public class EnumTest
  3. {
  4. /**
  5. * @param args
  6. */
  7. public static void main(String[] args)
  8. {
  9. EnumConstant[] allday = EnumConstant.values();
  10. System.out.println("-----------for begin------------------");
  11. for (EnumConstant day : allday)
  12. {
  13. System.out.println("  name ： " + day.name());//枚举变量的名称
  14. System.out.println("  ordinal ： " + day.ordinal());//枚举变量的序号
  15. System.out.println("  ： " + day);//就是toString()的返回值
  16. System.out.println("  key ： " + day.getKey());//取得第一个参数
  17. System.out.println("  value ： " + day.getValue());//取得第二个参数
  18. }
  19. System.out.println("-----------for end------------------");
  20. System.out.println(EnumConstant.WEEK_00);//就是toString()的返回值
  21. System.out.println(EnumConstant.WEEK_01);//就是toString()的返回值
  22. System.out.println(EnumConstant.WEEK_02);//就是toString()的返回值
  23. System.out.println(EnumConstant.WEEK_03);//就是toString()的返回值
  24. }
  25. }

PS：我常把Light叫做枚举类型，把其中的RED等叫做枚举变量或枚举值。

本以为RED只是一个Light类的一个static final的实例而已。但后然发现不是这样的，所以文中相关表述不正确的已加中划线，

正确的枚举类型原理见下一篇，Java学习整理系列之Java枚举类型的原理http://blog.csdn.net/sup_heaven/article/details/355591

原文地址：https://www.cnblogs.com/Jesuslovesme/p/8982595.html

时间： 2024-11-11 03:13:10

【转载】Java枚举类型的使用的相关文章

向Java枚举类型中添加新方法

除了不能继承enum之外,可将其看做一个常规类.甚至可以有main方法. 注意:必须先定义enum实例,实例的最后有一个分号. 下面是一个例子:返回对实例自身的描述,而非默认的toString返回枚举实例的名字. public enum Color { RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4); // 成员变量 private String nam

java 枚举类型分析

最近做android开发,需要用到枚举值,这样可以连续赋值,我按之前c++那样书写,如下所示: public enum ColorSelect { RED_BAGE = 0, GREEN_BAGE, BLUE_BAGE; } 编译不过. 我将赋值语句修改了以后,如下所示: public enum ColorSelect { RED_BAGE , GREEN_BAGE, BLUE_BAGE; } 编译通过.说明C++那样的赋值方法不适用java.所以,我需要弄清楚的是: 1. 在java平台上,如

【转】掌握java枚举类型(enum type)

原文网址:http://iaiai.iteye.com/blog/1843553 1   背景 在java语言中还没有引入枚举类型之前,表示枚举类型的常用模式是声明一组具有int常量.之前我们通常利用public final static 方法定义的代码如下,分别用1 表示春天,2表示夏天,3表示秋天,4表示冬天. Java代码   public class Season { public static final int SPRING = 1; public static final int 

【转】java枚举类型enum的使用

原文网址:http://blog.csdn.net/wgw335363240/article/details/6359614 java 枚举类型enum 的使用 最近跟同事讨论问题的时候,突然同事提到我们为什么java 中定义的常量值不采用enmu 枚举类型,而采用public final static 类型来定义呢?以前我们都是采用这种方式定义的,很少采用enum 定义,所以也都没有注意过,面对突入起来的问题,还真有点不太清楚为什么有这样的定义.既然不明白就抽时间研究下吧. Java 中的枚举

java 枚举类型enum 的使用

java 枚举类型enum 的使用 最近跟同事讨论问题的时候,突然同事提到我们为什么java 中定义的常量值不采用enmu 枚举类型,而采用public final static 类型来定义呢?以前我们都是采用这种方式定义的,很少采用enum 定义,所以也都没有注意过,面对突入起来的问题,还真有点不太清楚为什么有这样的定义.既然不明白就抽时间研究下吧. Java 中的枚举类型采用关键字enum 来定义,从jdk1.5才有的新类型,所有的枚举类型都是继承自Enum 类型.要了解枚举类型,建议大家先

深入理解Java枚举类型(enum)

[版权申明]未经博主同意,谢绝转载!(请尊重原创,博主保留追究权) http://blog.csdn.net/javazejian/article/details/71333103 出自[zejian的博客] 关联文章: 理解Java位运算 深入理解Java类型信息(Class对象)与反射机制 本篇主要是深入对Java中枚举类型进行分析,主要内容如下: 理解枚举类型 枚举的定义 枚举实现原理 枚举的常见方法 Enum抽象类常见方法 编译器生成的Values方法与ValueOf方法 枚举与Clas

java枚举类型的实现原理

Java从JDK1.5开始支持枚举,也就是说,Java一开始是不支持枚举的,就像泛型一样,都是JDK1.5才加入的新特性.通常一个特性如果在一开始没有提供,在语言发展后期才添加,会遇到一个问题,就是向后兼容性的问题.像Java在1.5中引入的很多特性,为了向后兼容,编译器会帮我们写的源代码做很多事情,比如泛型为什么会擦除类型,为什么会生成桥接方法,foreach迭代,自动装箱/拆箱等,这有个术语叫"语法糖",而编译器的特殊处理叫"解语法糖".那么像枚举也是在JDK1

java枚举类型

jvm并不支持枚举类型,java中枚举类型是在编译器层面上实现的,先看如下代码: package demo.nio; public class EnumDemo { public static enum Color{ Red(20), Green(10), Blue(30); Color(int v){ this.value = v; } private int value; public int getValue(){ return this.value; } } public static

java枚举类型详解

枚举类型是JDK1.5的新特性.显然,enum很像特殊的class,实际上enum声明定义的类型就是一个类.而这些类都是类库中Enum类的子类(java.lang.Enum<E>).它们继承了这个Enum中的许多有用的方法. 示例: 1 public enum Color { 2 3 RED("红色"),BLUE("蓝色"),WHITE("白色"),BLACK("黑色"),YELLO("黄色")