首页 > 编程语言 > 详细

java enum

时间：2017-04-06 17:43:04      阅读：126      评论：0      收藏：0      [点我收藏+]

Java Enum原理 

 

 
  1. public enum Size{ SMALL, MEDIUM, LARGE, EXTRA_LARGE };  


实际上，这个声明定义的类型是一个类，它刚好有四个实例，在此尽量不要构造新对象。

 

因此，在比较两个枚举类型的值时，永远不需要调用equals方法，而直接使用"=="就可以了。(equals()方法也是直接使用==,  两者是一样的效果)

Java Enum类型的语法结构尽管和java类的语法不一样，应该说差别比较大。但是经过编译器编译之后产生的是一个class文件。该class文件经过反编译可以看到实际上是生成了一个类，该类继承了java.lang.Enum<E>。

  例如：

  1. public enum WeekDay {   
  2.      Mon("Monday"), Tue("Tuesday"), Wed("Wednesday"), Thu("Thursday"), Fri( "Friday"), Sat("Saturday"), Sun("Sunday");   
  3.      private final String day;   
  4.      private WeekDay(String day) {   
  5.             this.day = day;   
  6.      }   
  7.     public static void printDay(int i){   
  8.        switch(i){   
  9.            case 1: System.out.println(WeekDay.Mon); break;   
  10.            case 2: System.out.println(WeekDay.Tue);break;   
  11.            case 3: System.out.println(WeekDay.Wed);break;   
  12.             case 4: System.out.println(WeekDay.Thu);break;   
  13.            case 5: System.out.println(WeekDay.Fri);break;   
  14.            case 6: System.out.println(WeekDay.Sat);break;   
  15.             case 7: System.out.println(WeekDay.Sun);break;   
  16.            default:System.out.println("wrong number!");   
  17.          }   
  18.      }   
  19.     public String getDay() {   
  20.         return day;   
  21.      }   
  22. }   

WeekDay经过反编译(javap WeekDay命令)之后得到的内容如下(去掉了汇编代码)：

  1. public final class WeekDay extends java.lang.Enum{   
  2.     public static final WeekDay Mon;   
  3.     public static final WeekDay Tue;   
  4.     public static final WeekDay Wed;   
  5.     public static final WeekDay Thu;   
  6.     public static final WeekDay Fri;   
  7.     public static final WeekDay Sat;   
  8.     public static final WeekDay Sun;   
  9.     static {};   
  10.     public static void printDay(int);   
  11.     public java.lang.String getDay();   
  12.     public static WeekDay[] values();   
  13.     public static WeekDay valueOf(java.lang.String);   
  14. }  

用法一：常量

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

 
  1. public enum Color {    
  2.   RED, GREEN, BLANK, YELLOW    
  3. }   

用法二：switch

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

[java] view plain copy
 
 技术分享技术分享
  1. enum Signal {  
  2.         GREEN, YELLOW, RED  
  3.     }  
  4.   
  5.     public class TrafficLight {  
  6.         Signal color = Signal.RED;  
  7.   
  8.         public void change() {  
  9.             switch (color) {  
  10.             case RED:  
  11.                 color = Signal.GREEN;  
  12.                 break;  
  13.             case YELLOW:  
  14.                 color = Signal.RED;  
  15.                 break;  
  16.             case GREEN:  
  17.                 color = Signal.YELLOW;  
  18.                 break;  
  19.             }  
  20.         }  
  21.     }  

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

如果打算自定义自己的方法，那么必须在enum实例序列的最后添加一个分号。而且 Java 要求必须先定义 enum 实例。

 

  1. public enum Color {  
  2.         RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
  3.         // 成员变量  
  4.         private String name;  
  5.         private int index;  
  6.   
  7.         // 构造方法  
  8.         private Color(String name, int index) {  
  9.             this.name = name;  
  10.             this.index = index;  
  11.         }  
  12.   
  13.         // 普通方法  
  14.         public static String getName(int index) {  
  15.             for (Color c : Color.values()) {  
  16.                 if (c.getIndex() == index) {  
  17.                     return c.name;  
  18.                 }  
  19.             }  
  20.             return null;  
  21.         }  
  22.   
  23.         // get set 方法  
  24.         public String getName() {  
  25.             return name;  
  26.         }  
  27.   
  28.         public void setName(String name) {  
  29.             this.name = name;  
  30.         }  
  31.   
  32.         public int getIndex() {  
  33.             return index;  
  34.         }  
  35.   
  36.         public void setIndex(int index) {  
  37.             this.index = index;  
  38.         }  
  39.     }  

用法四：覆盖枚举的方法

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

 

  1. public class Test {  
  2.     public enum Color {  
  3.         RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
  4.         // 成员变量  
  5.         private String name;  
  6.         private int index;  
  7.   
  8.         // 构造方法  
  9.         private Color(String name, int index) {  
  10.             this.name = name;  
  11.             this.index = index;  
  12.         }  
  13.   
  14.         // 覆盖方法  
  15.         @Override  
  16.         public String toString() {  
  17.             return this.index + "_" + this.name;  
  18.         }  
  19.     }  
  20.   
  21.     public static void main(String[] args) {  
  22.         System.out.println(Color.RED.toString());  
  23.     }  
  24. }  

 

用法五：实现接口

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

 

  1. public interface Behaviour {  
  2.         void print();  
  3.   
  4.         String getInfo();  
  5.     }  
  6.   
  7.     public enum Color implements Behaviour {  
  8.         RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
  9.         // 成员变量  
  10.         private String name;  
  11.         private int index;  
  12.   
  13.         // 构造方法  
  14.         private Color(String name, int index) {  
  15.             this.name = name;  
  16.             this.index = index;  
  17.         }  
  18.   
  19.         // 接口方法  
  20.   
  21.         @Override  
  22.         public String getInfo() {  
  23.             return this.name;  
  24.         }  
  25.   
  26.         // 接口方法  
  27.         @Override  
  28.         public void print() {  
  29.             System.out.println(this.index + ":" + this.name);  
  30.         }  
  31.     }  

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

 

  1. public interface Food {  
  2.         enum Coffee implements Food {  
  3.             BLACK_COFFEE, DECAF_COFFEE, LATTE, CAPPUCCINO  
  4.         }  
  5.   
  6.         enum Dessert implements Food {  
  7.             FRUIT, CAKE, GELATO  
  8.         }  
  9.     }  

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

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

三、 完整示例代码

枚举类型的完整演示代码如下：

  1. public class LightTest {  
  2.   
  3.     // 1.定义枚举类型  
  4.   
  5.     public enum Light {  
  6.   
  7.         // 利用构造函数传参  
  8.   
  9.         RED(1), GREEN(3), YELLOW(2);  
  10.   
  11.         // 定义私有变量  
  12.   
  13.         private int nCode;  
  14.   
  15.         // 构造函数，枚举类型只能为私有  
  16.   
  17.         private Light(int _nCode) {  
  18.   
  19.             this.nCode = _nCode;  
  20.   
  21.         }  
  22.   
  23.         @Override  
  24.         public String toString() {  
  25.   
  26.             return String.valueOf(this.nCode);  
  27.   
  28.         }  
  29.   
  30.     }  
  31.   
  32.     /** 
  33.      *  
  34.      * @param args 
  35.      */  
  36.   
  37.     public static void main(String[] args) {  
  38.   
  39.         // 1.遍历枚举类型  
  40.   
  41.         System.out.println("演示枚举类型的遍历 ......");  
  42.   
  43.         testTraversalEnum();  
  44.   
  45.         // 2.演示EnumMap对象的使用  
  46.   
  47.         System.out.println("演示EnmuMap对象的使用和遍历.....");  
  48.   
  49.         testEnumMap();  
  50.   
  51.         // 3.演示EnmuSet的使用  
  52.   
  53.         System.out.println("演示EnmuSet对象的使用和遍历.....");  
  54.   
  55.         testEnumSet();  
  56.   
  57.     }  
  58.   
  59.     /** 
  60.      *  
  61.      * 演示枚举类型的遍历 
  62.      */  
  63.   
  64.     private static void testTraversalEnum() {  
  65.   
  66.         Light[] allLight = Light.values();  
  67.   
  68.         for (Light aLight : allLight) {  
  69.   
  70.             System.out.println("当前灯name：" + aLight.name());  
  71.   
  72.             System.out.println("当前灯ordinal：" + aLight.ordinal());  
  73.   
  74.             System.out.println("当前灯：" + aLight);  
  75.   
  76.         }  
  77.   
  78.     }  
  79.   
  80.     /** 
  81.      *  
  82.      * 演示EnumMap的使用，EnumMap跟HashMap的使用差不多，只不过key要是枚举类型 
  83.      */  
  84.   
  85.     private static void testEnumMap() {  
  86.   
  87.         // 1.演示定义EnumMap对象，EnumMap对象的构造函数需要参数传入,默认是key的类的类型  
  88.   
  89.         EnumMap<Light, String> currEnumMap = new EnumMap<Light, String>(  
  90.   
  91.         Light.class);  
  92.   
  93.         currEnumMap.put(Light.RED, "红灯");  
  94.   
  95.         currEnumMap.put(Light.GREEN, "绿灯");  
  96.   
  97.         currEnumMap.put(Light.YELLOW, "黄灯");  
  98.   
  99.         // 2.遍历对象  
  100.   
  101.         for (Light aLight : Light.values()) {  
  102.   
  103.             System.out.println("[key=" + aLight.name() + ",value="  
  104.   
  105.             + currEnumMap.get(aLight) + "]");  
  106.   
  107.         }  
  108.   
  109.     }  
  110.   
  111.     /** 
  112.      *  
  113.      * 演示EnumSet如何使用，EnumSet是一个抽象类，获取一个类型的枚举类型内容<BR/> 
  114.      *  
  115.      * 可以使用allOf方法 
  116.      */  
  117.   
  118.     private static void testEnumSet() {  
  119.   
  120.         EnumSet<Light> currEnumSet = EnumSet.allOf(Light.class);  
  121.   
  122.         for (Light aLightSetElement : currEnumSet) {  
  123.   
  124.             System.out.println("当前EnumSet中数据为：" + aLightSetElement);  
  125.   
  126.         }  
  127.   
  128.     }  
  129.   
  130. }  
 

 

执行结果如下：

演示枚举类型的遍历 ......

当前灯name：RED

当前灯ordinal：0

当前灯：1

当前灯name：GREEN

当前灯ordinal：1

当前灯：3

当前灯name：YELLOW

当前灯ordinal：2

当前灯：2

演示EnmuMap对象的使用和遍历.....

[key=RED,value=红灯]

[key=GREEN,value=绿灯]

[key=YELLOW,value=黄灯]

演示EnmuSet对象的使用和遍历.....

当前EnumSet中数据为：1

当前EnumSet中数据为：3

当前EnumSet中数据为：2

 

 

1. 所有的枚举类型都是Enum类的子类。 它们继承了这个类的许多方法。其中最有用的一个方法是toString()，这个方法能够返回枚举常量名。   toString()方法的逆方法是静态方法valueOf(Class, String). 例如 Light lt = (Light) Enum.valueOf(Light.class, "RED"); 将lt设置为 Light.RED。 每个枚举类型都有一个静态的values()方法，它将返回一个包含全部枚举值的数组。   ordinal()方法返回enum声明中枚举常量的位置，位置从0开始计数。例如  Light.GREEN.ordinal()返回1。   Enum类实现了Comparable接口，  int  compareTo( E other)  如果枚举常量在other之前，则返回一个负值； 如果this==other，则返回0；否则，返回正值。 枚举常量的出现次序在enum 声明中给出。（所以不能直接用<,>符号比较两个枚举值）

2. 可以创建一个enum类，把它看做一个普通的类。除了它不能继承其他类了。(java是单继承，它已经继承了Enum),

可以添加其他方法，覆盖它本身的方法

3. switch()参数可以使用enum了

4. values()方法是编译器插入到enum定义中的static方法，所以，当你将enum实例向上转型为父类Enum是，values()就不可访问了。解决办法：在Class中有一个getEnumConstants()方法，所以即便Enum接口中没有values()方法，我们仍然可以通过Class对象取得所有的enum实例

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

6. 使用EnumSet代替标志。enum要求其成员都是唯一的，但是enum中不能删除添加元素。

7. EnumMap的key是enum，value是任何其他Object对象。

8. enum允许程序员为eunm实例编写方法。所以可以为每个enum实例赋予各自不同的行为。

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

10. 使用enum的状态机

11. 使用enum多路分发

java enum

原文：http://www.cnblogs.com/jtlgb/p/6674562.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
分享档案
更多>
2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)
最新文章
更多>
教程昨日排行
更多>
友情链接
汇智网   PHP教程   插件网  
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣，分享程序人生！