关键词搜索

源码搜索 ×
×

Java枚举类型enum

发布2016-01-22浏览11742次

详情内容

欢迎支持笔者新作：《深入理解Kafka:核心设计与实践原理》和《RabbitMQ实战指南》，同时欢迎关注笔者的微信公众号：朱小厮的博客。

欢迎跳转到本文的原文链接：https://honeypps.com/java/java-enum/

枚举的语法
1.Enum的全称为enumeration,中文俗称枚举类,学过C/C++等语言的人，应该都对它略知一二。
    但在Java语言规范中,是在JDK 5版本中才引入的，存放在 java.lang 包中。在Java版的Enum实质是语法糖,其声明方式如下:

 

【代码1】

 

 

  1. package com.enumtest;
  2. public enum Color
  3. {
  4.     RED,BLUE,BLACK,YELLOW,GREEN   //注意这里可以没有分号
  5. }

  enum是用来声明枚举的关键字,声明定义的类都隐含继承了一个父类(java.lang.Enum<E>),因此枚举不能再继承,但仍可实现接口。
    该父类有两个私有属性name(枚举类型的名称)和ordinal(枚举实例被创建的序数),分别通过name()和ordinal()暴露出来了.
    定义在枚举类型里的每一个枚举实例都将映射到Enum的子类中,其实例的名称和在枚举类型里定义的顺序都会传入到这个构造函数里 : protected Enum(String name, int ordinal)。
2.如果想更清楚了解一下Enum,可以用反编译工具把自己定义的枚举反编译一下就一目了然了,它就是一个普通的类,只是Java语言规范从Code角度进行了限制,执行javap com.enumtest.Color命令如下:
【代码2】

 

  1. package com.enumtest;
  2.   public final class Color extends  java.lang.Enum{ 
  3.     public static final Color RED; 
  4.     public static final Color BLUE; 
  5.     public static final Color BLACK; 
  6.     public static final Color YELLOW; 
  7.     public static final Color GREEN; 
  8.     static {}; 
  9.     public static Color[] values(); 
  10.     public static Color valueOf(java.lang.String); 
  11. }

3.所有枚举类都继承了Enum的方法，下面我们详细介绍这些方法。
(1) ordinal()方法: 返回枚举值在枚举类种的顺序。这个顺序根据枚举值声明的顺序而定。
    Color.RED.ordinal(); //返回结果：0
    Color.BLUE.ordinal(); //返回结果：1
(2) compareTo()方法: Enum实现了java.lang.Comparable接口，因此可以比较象与指定对象的顺序。Enum中的compareTo返回的是两个枚举值的顺序之差。当然，前提是两个枚举值必须属于同一个枚举类，否则会抛出ClassCastException()异常。(具体可见源代码)
    Color.RED.compareTo(Color.BLUE); //返回结果 -1
(3) values()方法： 静态方法，返回一个包含全部枚举值的数组。
    Color[] colors=Color.values();
    for(Color c:colors){
        System.out.print(c+",");
    }//返回结果：RED,BLUE,BLACK YELLOW,GREEN,
(4) toString()方法： 返回枚举常量的名称。
    Color c=Color.RED;
    System.out.println(c);//返回结果: RED
(5) valueOf()方法： 这个方法和toString方法是相对应的，返回带指定名称的指定枚举类型的枚举常量。
    Color.valueOf("BLUE"); //返回结果: Color.BLUE
(6) equals()方法： 比较两个枚举类对象的引用。
4. 如果定义的枚举有自己的构造函数必须声明私有的。

 

 

 

5. 注意以下区别：
【代码3】

 

  1. enum Color3{}
  2.  
  3. enum Color4
  4. {
  5.     RED
  6. }
  7.  
  8. enum Color5
  9. {
  10.     RED;
  11. }
  12.  
  13. enum Color6
  14. {
  15.     RED;
  16.     public void test(){}
  17. }
  18.  
  19. enum Color7
  20. {
  21.     public void test(){}
  22.    // RED;  //错误！！！！
  23. }
  24.  
  25. enum Color8
  26. {
  27.     ;
  28.     public void test(){}
  29. }

在enum Color3中是一个空的枚举；在enum Color4和Color5中有一个RED的枚举值，后面可以加分号或者不加分号；如果在枚举值后面添加方法，那么在枚举值的最后添加一个分号，如enum Color6；如果像enum Color7一样想把枚举值定义在方法后面是非法的，编译器会提示错误；当然也可以像enum Color8一样定义，注意方法test()之前的分号。

 

枚举的用法
(1) 常用于对同一类常量进行分类。见代码1.
(2) 声明接口方法时,输入参数类型采用枚举比用原始类型值常量更严谨.
(3) 常量有时往往不仅仅只是一个值,有可能会包含多个属性,此时很适合用枚举
(4) 有时常量对象需要从配置文件中读取其描述信息或者UI显示信息,此时也适合用枚举
(5) 从Java语法层面来说,枚举可以在switch使用,在if中可直接进行比较 。
【代码4】

 

  1. package com.enumtest;
  2.  
  3. public enum Color 
  4. {
  5.     RED,BLUE,BLACK,YELLOW,GREEN; //注意这里有分号
  6.  
  7.     public static void valuePrint(Color color)
  8.     {
  9.         switch(color)
  10.         {
  11.             case RED:
  12.                 System.out.println(RED);
  13.                 break;
  14.             case BLUE:
  15.                 System.out.println(BLUE);
  16.                 break;
  17.             case BLACK:
  18.                 System.out.println(BLACK);
  19.                 break;
  20.             case YELLOW:
  21.                 System.out.println(YELLOW);
  22.                 break;
  23.             case GREEN:
  24.                 System.out.println(GREEN);
  25.                 break;
  26.             default:
  27.                 break;
  28.         }
  29.     }
  30.  
  31.     public static void main(String args[])
  32.     {
  33.         Color color = Color.RED;
  34.         valuePrint(color);
  35.         EnumTest.valuePrint(color);
  36.     }
  37. }
  38.  
  39. class EnumTest
  40. {
  41.     public static void valuePrint(Color color)
  42.     {
  43.         switch(color)
  44.         {
  45.             case RED:
  46.                 System.out.println(Color.RED);//注意这里的Color.RED不能写成RED，而case中的必须写成RED。
  47.                 break;
  48.             case BLUE:
  49.                 System.out.println(Color.BLUE);
  50.                 break;
  51.             case BLACK:
  52.                 System.out.println(Color.BLACK);
  53.                 break;
  54.             case YELLOW:
  55.                 System.out.println(Color.YELLOW);
  56.                 break;
  57.             case GREEN:
  58.                 System.out.println(Color.GREEN);
  59.                 break;
  60.             default:
  61.                 break;
  62.         }
  63.     }
  64. }

运行结果：

RED
RED

(6) 声明枚举属性时最好用public final修饰,使用起来会非常方便
(7) 自定义枚举时,建议不要使用自带的name()和ordinal()方法返回值来与原始值类型转换,这样业务不依赖其枚举的名字和顺序
【代码5】

  1. package com.enumtest;
  2.  
  3. public enum Color2
  4. {
  5.     RED("红色",1),BLUE("蓝色",2),BLACK("黑色",3),YELLOW("黄色",4),GREEN("绿色",5);
  6.  
  7.     public final String name;
  8.     public final int index;
  9.  
  10.     private Color2(String name, int index)
  11.     {
  12.         this.name = name;
  13.         this.index = index;
  14.     }
  15.  
  16.     public static String getName(int index)
  17.     {
  18.         for(Color2 c: Color2.values())
  19.         {
  20.             if(c.getIndex() == index)
  21.             {
  22.                 return c.name;
  23.             }
  24.         }
  25.         return null;
  26.     }
  27.  
  28.     public static void main(String[] args)
  29.     {
  30.         System.out.println(getName(1));
  31.     }
  32.  
  33.     public String getName()
  34.     {
  35.         return name;
  36.     }
  37.  
  38.     public int getIndex()
  39.     {
  40.         return index;
  41.     }
  42. }

运行结果：红色
(8) 重载枚举的方法toString
【代码6】

 

 

  1. package com.enumtest;
  2.  
  3. public enum Color2
  4. {
  5.     RED("红色",1),BLUE("蓝色",2),BLACK("黑色",3),YELLOW("黄色",4),GREEN("绿色",5);
  6.  
  7.     public final String name;
  8.     public final int index;
  9.  
  10.     private Color2(String name, int index)
  11.     {
  12.         this.name = name;
  13.         this.index = index;
  14.     }
  15.  
  16.     public static String getName(int index)
  17.     {
  18.         for(Color2 c: Color2.values())
  19.         {
  20.             if(c.getIndex() == index)
  21.             {
  22.                 return c.toString();
  23.             }
  24.         }
  25.         return null;
  26.     }
  27.  
  28.     public static void main(String[] args)
  29.     {
  30.         System.out.println(getName(1));
  31.     }
  32.  
  33.     @Override
  34.     public String toString()
  35.     {
  36.         return this.index+"_"+this.name;
  37.     }
  38.  
  39.     public String getName()
  40.     {
  41.         return name;
  42.     }
  43.  
  44.     public int getIndex()
  45.     {
  46.         return index;
  47.     }
  48. }

(9)实现接口。所有的枚举都继承自java.lang.Enum类。由于java不支持多继承，所以枚举对象不能再继承其他的类。
【代码7】

  1. package com.enumtest;
  2.  
  3. public interface Behaviour
  4. {
  5.     void print();
  6.     String getInfo();
  7. }

【代码8】

  1. package com.enumtest;
  2.  
  3. public enum Color9 implements Behaviour
  4. {
  5.     RED("红色",1),BLUE("蓝色",2),BLACK("黑色",3),YELLOW("黄色",4),GREEN("绿色",5);
  6.  
  7.     public final String name;
  8.     public final int index;
  9.  
  10.     private Color9(String name, int index)
  11.     {
  12.         this.name = name;
  13.         this.index = index;
  14.     }
  15.  
  16.     @Override
  17.     public void print()
  18.     {
  19.         System.out.println(this.index+":"+this.name);
  20.     }
  21.  
  22.     @Override
  23.     public String getInfo()
  24.     {
  25.         return this.name;
  26.     }
  27. }

(10) 可以创建一个enum类，把它看做一个普通的类。除了它不能继承其他类。（Java是单继承，它已经继承了Enum),可以添加其他的方法，覆盖它本身的方法。
(11) values()方法是编译器插入到enum定义中的static方法，所以，当你将enum实例向上转型为父类Enum是，values()就不可访问了。解决办法：在Class中有一个getEnumConstants()方法，所以即便Enum接口中没有values()方法，我们仍然可以通过Class对象取得所有的enum实例。
【代码9】

  1. package com.enumtest;
  2.  
  3. public enum Color 
  4. {
  5.     RED,BLUE,BLACK,YELLOW,GREEN; //注意这里有分号
  6.  
  7.     public void print()
  8.     {
  9.         for(Color c : Color.class.getEnumConstants())
  10.         {
  11.             System.out.println(c.toString());
  12.         }
  13.     }
  14.  
  15.     public static void main(String args[])
  16.     {
  17.         Color.RED.print();
  18.     }
  19. }

(12) 无法从enum继承子类，如果需要扩展enum中的元素，在一个接口的内部，创建实现该接口的枚举，以此将元素进行分组。达到将枚举元素进行分组。
【代码10】

  1. package com.enumtest;
  2.  
  3. public interface Food
  4. {
  5.     enum Coffee implements Food 
  6.     {
  7.         BLACK_COFFEE, DECAF_COFFEE,LATTE;
  8.     }
  9.  
  10.     enum Dessert implements Food
  11.     {
  12.         FRUIT,CAKE,GELATO;
  13.     }
  14. }

(13) java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复;EnumMap中的 key是enum类型，而value则可以是任意类型。
【代码11】

  1. package com.enumtest;
  2.  
  3. import java.util.EnumMap;
  4. import java.util.EnumSet;
  5. import java.util.Set;
  6.  
  7. public class LightTest
  8. {
  9.     public enum Light{
  10.         RED(1),GREEN(2),YELLOW(3);
  11.  
  12.         public final int nCode;
  13.  
  14.         private Light(int nCode)
  15.         {
  16.             this.nCode = nCode;
  17.         }
  18.     }
  19.  
  20.     public static void testTraversalEnum()
  21.     {
  22.         Light[] allLight = Light.values();
  23.         for(Light aLight:allLight)
  24.         {
  25.             System.out.println(aLight.name()+" "+aLight.ordinal()+" "+aLight);
  26.         }
  27.     }
  28.  
  29.     public static void testEnumMap()
  30.     {
  31.         EnumMap<Light,String> currEnumMap = new EnumMap<Light,String>(Light.class);
  32.         currEnumMap.put(Light.RED, "红色");
  33.         currEnumMap.put(Light.GREEN, "绿色");
  34.         currEnumMap.put(Light.YELLOW, "黄色");
  35.         Set<Light> set = currEnumMap.keySet();
  36.         for(Light aLight:set)
  37.         {
  38.             System.out.println(aLight.name()+" "+aLight.ordinal()+" "+aLight);
  39.         }
  40.     }
  41.  
  42.     public static void testEnumSet()
  43.     {
  44.         EnumSet<Light> currEnumSet = EnumSet.allOf(Light.class);
  45.         for(Light aLightSetElement : currEnumSet)
  46.         {
  47.             System.out.println(aLightSetElement);
  48.         }
  49.     }
  50.  
  51.     public static void main(String[] args)
  52.     {
  53.         testTraversalEnum();
  54.         testEnumMap();
  55.         testEnumSet();
  56.     }
  57. }

运行结果：（略）
(14) 使用enum的职责链(Chain of Responsibility) .这个关系到设计模式的职责链模式。以多种不同的方法来解决一个问题。然后将他们链接在一起。当一个请求到来时，遍历这个链，直到链中的某个解决方案能够处理该请求。

欢迎跳转到本文的原文链接：https://honeypps.com/java/java-enum/

欢迎支持笔者新作：《深入理解Kafka:核心设计与实践原理》和《RabbitMQ实战指南》，同时欢迎关注笔者的微信公众号：朱小厮的博客。

相关技术文章

最新源码

下载排行榜
点击QQ咨询
开通会员
返回顶部
×
微信扫码支付 元
微信扫码支付
确定支付下载
请使用微信描二维码支付
×

提示信息

×

选择支付方式

  • 微信支付
  • 支付宝付款
确定支付下载