Java枚举类型

版权声明：本文为转载自Sup_Heaven的博客，原文链接为：http://blog.csdn.net/sup_heaven/article/details/35295851。

枚举类型概念

[java]  view plain  copy

 

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

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

由此说明定义枚举类型其实就是在定义一个类，只不过很多细节由编译器帮你补齐了，所以，某种程度上enum关键词的作用就像是class或interface.当使用enum定义枚举类型时，实际上所定义出来的类型是继承自java.lang.Enum类。

Java枚举类型的案例一

[java]  view plain  copy

 

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

Java枚举类型的案例二

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

[java]  view plain  copy

 

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

Java枚举类型的案例三

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

[java]  view plain  copy

 

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

[java]  view plain  copy

 

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

本以为RED只是一个Color类的一个static final的实例而已。但后然发现不是这样的，先看看下面的一种枚举类型使用的代码。

[java]  view plain  copy

 

1. package com.lxq.enumm;  
2.   
3. public enum Color  
4. {  
5.     RED{  
6.         public String getName(){  
7.             return "红色";  
8.         }  
9.     }  
10.     ,GREEN{  
11.         public String getName(){  
12.             return "绿色";  
13.         }  
14.     }  
15.     ,YELLOW{  
16.         public String getName(){  
17.             return "黄色";  
18.         }  
19.     };  
20.     public abstract String getName();  
21. }  

如果RED只是一个Color类的一个static final的实例，那么上面的代码就很让了费解了，为什么在枚举类型中可以有一个抽象方法，而每个枚举值可以对其重新实现？

别急，看了我对这个类的测试代码你就明白，测试代码如下：

[java]  view plain  copy

 

1. import java.lang.reflect.Modifier;  
2.   
3. public class EnumDemoFour{  
4.     public static void main(String[] args){  
5.         //打印该枚举值的名称  
6.         System.out.println(Color.RED.getName());  
7.         //打印该枚举值的类  
8.         System.out.println(Color.RED.getClass());  
9.         //打印该枚举值的类的父类  
10.         System.out.println(Color.RED.getClass().getSuperclass());  
11.         //打印该枚举值的类的父类的父类  
12.         System.out.println(Color.RED.getClass().getSuperclass().getSuperclass());  
13.         //打印该枚举类型的修饰符  
14.         System.out.println(Modifier.toString(Color.class.getModifiers()));  
15.     }     
16.     /*运行结果 
17.     红色 
18.     class com.lxq.enumm.Color$1 
19.     class com.lxq.enumm.Color 
20.     class java.lang.Enum 
21.     public abstract*/  
22. }  

该运行结果首先说明了RED和Color不是同一个类，而是前者是后者的一个子类；同时也说明了enum申明的其实是一个abstract的类，所以Color中可以有抽象方法。

那么，我们应该这么理解枚举类型的原理，首先enum Color继承了java.lang.Enum这个抽象类，但enum Color还是一个抽象类，所以它可以有抽象方法和非抽象方法。

而enum Color中的枚举值变量RED事实上上Color的一个匿名子类，所以它可以实现Color中的抽象方法，这样，当我们调用System.out.println(Color.RED.getName());

就是调用了匿名子类实现的方法。当然这些过程的很多事都有编译器等为我们做了，所以这里的代码很简单。

要是你不明白上面打印的内容，我再提供一个普通的类给你看看，还是类似的效果哦。

[java]  view plain  copy

 

1. public abstract class TestInnerClass  
2. {  
3.     public abstract void dosomething();  
4.     public static void main(String[] args){  
5.         TestInnerClass tic=new TestInnerClass(){  
6.             @Override  
7.             public void dosomething()  
8.             {  
9.                 System.out.println("我是匿名子类");  
10.             }     
11.         };  
12.         tic.dosomething();  
13.         System.out.println(tic.getClass());  
14.     }  
15.     /*输出结果 
16.     我是匿名子类 
17.     class TestInnerClass$1 
18.     */  
19. }  

最后再附上网上一个 使用Java普通类模拟枚举的例子http://blog.csdn.net/xyang81/article/details/7185428，这个例子真的很好。

使用Java普通类模拟枚举

[java]  view plain  copy

 

1. import java.util.HashMap;  
2. import java.util.Map;  
3.   
4. /** 
5.  * 模拟星期中的表示的天，每个星期天都表示一个对象 
6.  * 1、类中的每一个枚举成员都是该类的一个实例对象 
7.  * 2、构造函数私有化 
8.  * 3、提供操作枚举成员的抽象方法和静态方法 
9.  */  
10. public abstract class WeekDate {  
11.     /** 
12.      * 星期一 
13.      */  
14.     public static final WeekDate MON = new WeekDate("MON",0) {//匿名子类  
15.         @Override  
16.         public WeekDate nextDay() {  
17.             return TUES;  
18.         }  
19.         @Override  
20.         public WeekDate preDay() {  
21.             return SUN;  
22.         }  
23.         @Override  
24.         public String toString() {  
25.             return "WeekDate.MON";  
26.         }  
27.     };    
28.       
29.     /** 
30.      * 星期二 
31.      */  
32.     public static final WeekDate TUES = new WeekDate("TUES",1) {  
33.         @Override  
34.         public WeekDate nextDay() {  
35.             return WEDNES;  
36.         }  
37.         @Override  
38.         public WeekDate preDay() {  
39.             return MON;  
40.         }  
41.         @Override  
42.         public String toString() {  
43.             return "WeekDate.TUES";  
44.         }  
45.     };  
46.       
47.     /** 
48.      * 星期三 
49.      */  
50.     public static final WeekDate WEDNES = new WeekDate("WEDNES",2) {  
51.         @Override  
52.         public WeekDate nextDay() {  
53.             return THURS;  
54.         }  
55.         @Override  
56.         public WeekDate preDay() {  
57.             return TUES;  
58.         }  
59.         @Override  
60.         public String toString() {  
61.             return "WeekDate.WEDNES";  
62.         }     
63.     };  
64.       
65.     /** 
66.      * 星期四 
67.      */  
68.     public static final WeekDate THURS = new WeekDate("THURS",3) {  
69.         @Override  
70.         public WeekDate nextDay() {  
71.             return FRI;  
72.         }  
73.         @Override  
74.         public WeekDate preDay() {  
75.             return WEDNES;  
76.         }         
77.         @Override  
78.         public String toString() {  
79.             return "WeekDate.THURS";  
80.         }         
81.     };  
82.       
83.     /** 
84.      * 星期五 
85.      */  
86.     public static final WeekDate FRI = new WeekDate("FRI",4){  
87.         @Override  
88.         public WeekDate nextDay() {  
89.             return SATUR;  
90.         }  
91.         @Override  
92.         public WeekDate preDay() {  
93.             return THURS;  
94.         }  
95.         @Override  
96.         public String toString() {  
97.             return "WeekDate.FRI";  
98.         }  
99.     };  
100.       
101.     /** 
102.      * 星期六 
103.      */  
104.     public static final WeekDate SATUR = new WeekDate("SATUR",5){  
105.         @Override  
106.         public WeekDate nextDay() {  
107.             return SUN;  
108.         }  
109.         @Override  
110.         public WeekDate preDay() {  
111.             return FRI;  
112.         }         
113.         @Override  
114.         public String toString() {  
115.             return "WeekDate.SATUR";  
116.         }         
117.     };  
118.       
119.     /** 
120.      * 星期日 
121.      */  
122.     public static final WeekDate SUN = new WeekDate("SUN",6){  
123.         @Override  
124.         public WeekDate nextDay() {  
125.             return MON;  
126.         }  
127.         @Override  
128.         public WeekDate preDay() {  
129.             return SATUR;  
130.         }  
131.         @Override  
132.         public String toString() {  
133.             return "WeekDate.SUN";  
134.         }  
135.     };  
136.       
137.     private static Map<String, WeekDate> valueMap = new HashMap<String, WeekDate>();  
138.       
139.     /** 
140.      * 枚举名称 
141.      */  
142.     private final String name;  
143.       
144.     /** 
145.      * 枚举成员的顺序 
146.      */  
147.     private final int ordinal;  
148.       
149.     private WeekDate(String name,int ordinal) {  
150.         this.name = name;  
151.         this.ordinal = ordinal;  
152.     }  
153.       
154.     /** 
155.      * 保存枚举成员 
156.      */  
157.     private static WeekDate[] values = {  
158.         MON,TUES,WEDNES,THURS,FRI,SATUR,SUN  
159.     };  
160.       
161.     //初始化  
162.     static {  
163.         valueMap.put("MON", values[0]);  
164.         valueMap.put("TUES", values[1]);  
165.         valueMap.put("WEDNES", values[2]);  
166.         valueMap.put("THURS", values[3]);  
167.         valueMap.put("FRI", values[4]);  
168.         valueMap.put("SATUR", values[5]);  
169.         valueMap.put("SUN", values[6]);  
170.     }  
171.       
172.     /** 
173.      * 下一天 
174.      * @return 
175.      */  
176.     public abstract WeekDate nextDay();  
177.       
178.     /** 
179.      * 前一天 
180.      * @return 
181.      */  
182.     public abstract WeekDate preDay();  
183.       
184.     /** 
185.      * 枚举中的所有成员 
186.      * @return 
187.      */  
188.     public static WeekDate[] values() {  
189.         return values;  
190.     }  
191.       
192.     /** 
193.      * 将一个字符串转换成一个枚举成员对象 
194.      * @param name 枚举名称 
195.      * @return 枚举对象 
196.      */  
197.     public static WeekDate valueOf(String name) {  
198.         if (name.equalsIgnoreCase("MON")) {  
199.             return MON;  
200.         } else if (name.equalsIgnoreCase("TUES")) {  
201.             return TUES;  
202.         } else if (name.equalsIgnoreCase("WEDES")) {  
203.             return WEDNES;  
204.         } else if (name.equalsIgnoreCase("THURS")) {  
205.             return THURS;  
206.         } else if (name.equalsIgnoreCase("FRI")) {  
207.             return FRI;  
208.         } else if (name.equalsIgnoreCase("SATUR")) {  
209.             return SATUR;  
210.         } else if (name.equalsIgnoreCase("SUN")) {  
211.             return SUN;  
212.         } else {  
213.             throw new IllegalArgumentException("找不到" + name + "枚举类型！");  
214.         }  
215.     }  
216.       
217.     /** 
218.      * 优化字符串转枚举对象 
219.      * @param name 枚举名称 
220.      * @return 枚举对象 
221.      */  
222.     public static WeekDate valueOf_2(String name) {  
223.         WeekDate value = valueMap.get(name.toUpperCase());  
224.         if (value == null) {  
225.             throw new IllegalArgumentException("找不到" + name + "枚举类型！");  
226.         }  
227.         return value;  
228.     }  
229.     public String getName() {  
230.         return name;  
231.     }  
232.     public int getOrdinal() {  
233.         return ordinal;  
234.     }  
235. }  

使用JDK5.0中提供的枚举特性

[java]  view plain  copy

 

1. /** 
2.  * 枚举的应用 
3.  * 存储每周中的天份 
4.  */  
5. public enum WeekDateEnum {  
6.   
7.     MON {  
8.           
9.         @Override  
10.         public WeekDateEnum nextDay() {  
11.             return TUES;  
12.         }  
13.           
14.         @Override  
15.         public WeekDateEnum preDay() {  
16.             return SUN;  
17.         }  
18.           
19.     },  TUES {  
20.           
21.         @Override  
22.         public WeekDateEnum nextDay() {  
23.             return WEDNES;  
24.         }  
25.           
26.         @Override  
27.         public WeekDateEnum preDay() {  
28.             return MON;  
29.         }  
30.           
31.     },  WEDNES {  
32.           
33.         @Override  
34.         public WeekDateEnum nextDay() {  
35.             return THURS;  
36.         }  
37.           
38.         @Override  
39.         public WeekDateEnum preDay() {  
40.             return TUES;  
41.         }  
42.           
43.     },  THURS {  
44.           
45.         @Override  
46.         public WeekDateEnum nextDay() {  
47.             return FRI;  
48.         }  
49.           
50.         @Override  
51.         public WeekDateEnum preDay() {  
52.             return WEDNES;  
53.         }  
54.           
55.     },  FRI {  
56.           
57.         @Override  
58.         public WeekDateEnum nextDay() {  
59.             return SATUR;  
60.         }  
61.           
62.         @Override  
63.         public WeekDateEnum preDay() {  
64.             return THURS;  
65.         }  
66.           
67.     },  SATUR {  
68.           
69.         @Override  
70.         public WeekDateEnum nextDay() {  
71.             return SATUR;  
72.         }  
73.           
74.         @Override  
75.         public WeekDateEnum preDay() {  
76.             return FRI;  
77.         }  
78.           
79.     },  SUN {  
80.           
81.         @Override  
82.         public WeekDateEnum nextDay() {  
83.             return SATUR;  
84.         }  
85.           
86.         @Override  
87.         public WeekDateEnum preDay() {  
88.             return MON;  
89.         }  
90.           
91.     };  
92.   
93.     private WeekDateEnum() {}  
94.       
95.     /** 
96.      * 下一天 
97.      * @return 
98.      */  
99.     public abstract WeekDateEnum nextDay();  
100.       
101.     /** 
102.      * 前一天 
103.      * @return 
104.      */  
105.     public abstract WeekDateEnum preDay();  
106.       
107.     /** 
108.      * 枚举对象公共的toString方法，可以在case块中反馈自己想要返回的信息 
109.      */  
110.     public String toString() {  
111.         switch (this) {  
112.         case MON:  
113.             return "WeekDateEnum.MON";  
114.         case TUES:  
115.             return "WeekDateEnum.TUES";  
116.         case WEDNES:  
117.             return "WeekDateEnum.WEDNES";  
118.         case THURS:  
119.             return "WeekDateEnum.THURS";  
120.         case FRI:  
121.             return "WeekDateEnum.FRI";  
122.         case SATUR:  
123.             return "WeekDateEnum.SATUR";  
124.         case SUN:  
125.             return "WeekDateEnum.SUN";  
126.         default:  
127.             return null;  
128.         }  
129.     }  
130. }  

枚举功能测试

[java]  view plain  copy

 

1. /** 
2.  * 枚举功能测试 
3.  */  
4. public class EnumTest {  
5.   
6.     public static void main(String[] args) {  
7.           
8.         //使用普通JAVA类模拟枚举的应用  
9.         WeekDate weekDate = WeekDate.MON;       //获得一个枚举对象  
10.         //调用枚举中提供的方法  
11.         System.out.println(weekDate.nextDay());   
12.         System.out.println(weekDate.preDay());  
13.         System.out.println(weekDate.getName());  
14.         //获得枚举成员所在枚举成员列表中的位置  
15.         System.out.println(weekDate.getOrdinal());  
16.         //调用某一个枚举成员的方法  
17.         System.out.println(WeekDate.values()[0].preDay());  
18.         System.out.println("---------------遍历枚举成员,普通JAVA类模拟--------------------------");  
19.         for (WeekDate weekDate2 : WeekDate.values()) {  
20.             System.out.println(weekDate2);  
21.         }  
22.           
23.         System.out.println("\n=================================================================\n");  
24.           
25.         //使用JDK中提供的枚举特性功能应用  
26.         WeekDateEnum weekDateEnum = WeekDateEnum.MON;   //获得一个枚举对象  
27.         System.out.println(WeekDate.values().length);   //获得枚举成员数量  
28.         System.out.println(weekDateEnum.name());        //获得枚举的字符串名称  
29.         System.out.println(weekDateEnum.toString());    //打印枚举对象，已重写toString方法，默认打印枚举的名称  
30.         System.out.println(weekDateEnum.nextDay().ordinal());   //枚举成员列表中的位置  
31.         System.out.println(WeekDateEnum.valueOf("FRI").nextDay().ordinal());  
32.         System.out.println("---------------遍历枚举成员，使用JDK的枚举特性-------------------------");  
33.         for (WeekDateEnum enumDemo : WeekDateEnum.values()) {  
34.             System.out.println(enumDemo);  
35.         }  
36.           
37.     }   
38.       
39. }