java enum的用法详解

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

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

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

  例如：

[java]  view plain  copy

 

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命令)之后得到的内容如下(去掉了汇编代码)：

[java]  view plain  copy

 

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.... 。现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。

[java]  view plain  copy

 

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 实例。

[java]  view plain  copy

 

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()方法覆盖的例子。

[java]  view plain  copy

 

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 不支持多继承，所以枚举对象不能再继承其他类。

[java]  view plain  copy

 

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.     }  

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

[java]  view plain  copy

 

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文档

三、 完整示例代码

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

[java]  view plain  copy

 

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多路分发