Java - 枚举

传统模式实现Enum

[java]  view plain  copy

1. package com.itlwc;  
2.   
3. class MyEnum {  
4.     public static final int BOY = 0;  
5.     public static final int GIRL = 1;  
6. }  
7.   
8. class Student {  
9.     String name;  
10.     int age;  
11.   
12.     public Student(String name, int age) {  
13.         this.name = name;  
14.         if (age != 0 && age != 1) {  
15.             String errorMsg = "非法性别参数" + age + ",应该为1或者0";  
16.             throw new IllegalArgumentException(errorMsg);  
17.         } else {  
18.             this.age = age;  
19.         }  
20.     }  
21. }  
22.   
23. public class Test {  
24.     public static void main(String[] args) {  
25.         new Student("lwc", 0);//虽然不报错,但没有使用预定义的常量,逻辑错误  
26.         new Student("nxj", MyEnum.GIRL);  
27.     }  
28. }  

使用传统模式实现枚举几点不足

[plain]  view plain  copy

1. 必须单独声明每一个常量,并且赋值  
2. 接受枚举类型合法必须由开发人员自己开发  
3. 参数合法性不能在编译时直接指出,只能在运行时看到  

使用枚举类型实现

[java]  view plain  copy

1. package com.itlwc;  
2.   
3. enum MyEnum {  
4.     MALE, FAMALE  
5. }  
6.   
7. class Student {  
8.     String name;  
9.     MyEnum me;  
10.   
11.     public Student(String name, MyEnum me) {  
12.         this.name = name;  
13.         this.me = me;  
14.     }  
15. }  
16.   
17. public class Test {  
18.     public static void main(String[] args) {  
19.         new Student("lwc", 200);//直接报错  
20.         new Student("nxj", MyEnum.MALE);  
21.     }  
22. }  

使用枚举类型实现的优点

[java]  view plain  copy

1. 避免开发枚举值合法性代码,错误在编译时就会发现,提高了开发效率,避免了不必要的错误  

枚举(Enum)概述

[plain]  view plain  copy

1. 定义语法为  
2.     enum MyEnum{  
3.         MALE,FAMALE  
4.     }  
5. 自定义枚举都继承java.lang.Enum(抽象类)  
6. 枚举默认默认实现了java.lang.Comparable接口  
7. 枚举成员默认都是pubilc static final的(非枚举值可以不是)  
8. 枚举的成员就是枚举的实例,所以定义枚举类型之后,在编译时就能确定枚举类型有几个实例,  
9.     分别是什么,在运行期间再无法为枚举类型创建新的实例    
10. 枚举不可以有public或者protected的构造函数,这样可以保证客户代码不能新建一个枚举的实例    
11. 虽然枚举和类很相似,声明位置相同,但并不是一个类,他们最大的区别就是  
12.     类的对象是不确定的,new几次就生成几个,枚举的对象在编译期已经确定好了      

Enum遍历

[java]  view plain  copy

1. package com.itlwc;  
2.   
3. enum Week {  
4.     // 编译期已经确定下来Week有8个实例  
5.     SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, STR {  
6.         // 重写了toString方法  
7.         public String toString() {  
8.             return "输入参数有误,参数值范围在0~6";  
9.         }  
10.     };  
11. }  
12.   
13. public class Test {  
14.     public static void main(String[] args) {  
15.         // 引用枚举里面的值  
16.         System.out.println(Week.SUNDAY);  
17.         System.out.println("----------------------------");  
18.         // 静态方法values()返回定义枚举中枚举值的一个数组  
19.         for (Week w : Week.values()) {  
20.             // ordinal()返回枚举值的位置  
21.             System.out.println(w + "-->所在的顺序是" + w.ordinal());  
22.         }  
23.         System.out.println("----------------------------");  
24.         System.out.println(new Test().getWeek(7));  
25.     }  
26.   
27.     public Week getWeek(int i) {  
28.         switch (i) {  
29.         case 0:  
30.             return Week.SUNDAY;  
31.         case 1:  
32.             return Week.MONDAY;  
33.         case 2:  
34.             return Week.TUESDAY;  
35.         case 3:  
36.             return Week.WEDNESDAY;  
37.         case 4:  
38.             return Week.THURSDAY;  
39.         case 5:  
40.             return Week.FRIDAY;  
41.         case 6:  
42.             return Week.SATURDAY;  
43.         default:  
44.             return Week.STR;  
45.         }  
46.     }  
47. }  
48. /* 
49. 打印结果: 
50.     SUNDAY 
51.     ---------------------------- 
52.     SUNDAY-->所在的顺序是0 
53.     MONDAY-->所在的顺序是1 
54.     TUESDAY-->所在的顺序是2 
55.     WEDNESDAY-->所在的顺序是3 
56.     THURSDAY-->所在的顺序是4 
57.     FRIDAY-->所在的顺序是5 
58.     SATURDAY-->所在的顺序是6 
59.     输入参数有误,参数值范围在0~6-->所在的顺序是7 
60.     ---------------------------- 
61.     输入参数有误,参数值范围在0~6 
62. */  

Enum的构造器

简单构造器

[java]  view plain  copy

1. package com.itlwc;  
2.   
3. public enum MyEnum {  
4.     RED(), GREEN(), BLUE();  
5.     // 简单构造器  
6.     MyEnum() {  
7.     }  
8.   
9.     public static void main(String[] args) {  
10.         MyEnum c = MyEnum.BLUE;  
11.         System.out.println(c);  
12.     }  
13. }  
14. /* 
15. 打印结果: 
16.     BLUE 
17. */  

复杂构造器

[java]  view plain  copy

1. package com.itlwc;  
2.   
3. public enum MyEnum {  
4.     RED("红色"), GREEN("绿色"), BLUE("蓝色");  
5.     String name;  
6.     // 复杂构造器  
7.     MyEnum(String name) {  
8.         this.name = name;  
9.     }  
10.   
11.     public String getName() {  
12.         return name;  
13.     }  
14.   
15.     public void setName(String name) {  
16.         this.name = name;  
17.     }  
18.   
19.     public static void main(String[] args) {  
20.         MyEnum c = MyEnum.BLUE;  
21.         System.out.println(c.getName());  
22.         c.setName("设置的颜色");  
23.         System.out.println(c.getName());  
24.     }  
25. }  
26. /* 
27. 打印结果: 
28.     蓝色 
29.     设置的颜色 
30. */  

Enum实现接口

Enum实现接口,Enum中的每个对象都必须实现接口中的抽象方法

[java]  view plain  copy

1. package com.itlwc;  
2.   
3. interface Info {  
4.     public String getColor();  
5. }  
6.   
7. public enum MyEnum implements Info {  
8.     RED {  
9.         public String getColor() {  
10.             return "红色";  
11.         }  
12.     },  
13.     GREEN {  
14.         public String getColor() {  
15.             return "绿色";  
16.         }  
17.     },  
18.     BLUE {  
19.         public String getColor() {  
20.             return "蓝色";  
21.         }  
22.     };  
23.     public static void main(String[] args) {  
24.         for (MyEnum c : MyEnum.values()) {  
25.             System.out.println(c.ordinal() + "-->" + c.name() + ":"  
26.                     + c.getColor());  
27.         }  
28.     }  
29. }  
30. /* 
31. 打印结果: 
32.     0-->RED:红色 
33.     1-->GREEN:绿色 
34.     2-->BLUE:蓝色 
35. */  

Enum中定义抽象方法

Enum中直接定义抽象方法,每个对象必须单独实现抽象方法

[java]  view plain  copy

1. package com.itlwc;  
2.   
3. public enum MyEnum {  
4.     RED {  
5.         public String getColor() {  
6.             return "红色";  
7.         }  
8.     },  
9.     GREEN {  
10.         public String getColor() {  
11.             return "绿色";  
12.         }  
13.     },  
14.     BLUE {  
15.         public String getColor() {  
16.             return "蓝色";  
17.         }  
18.     };  
19.     public abstract String getColor();  
20.   
21.     public static void main(String[] args) {  
22.         for (MyEnum c : MyEnum.values()) {  
23.             System.out.println(c.ordinal() + "-->" + c.name() + ":"  
24.                     + c.getColor());  
25.         }  
26.     }  
27. }  
28. /* 
29. 打印结果: 
30.     0-->RED:红色 
31.     1-->GREEN:绿色 
32.     2-->BLUE:蓝色 
33. */  

EnumMap对Enum的支持

[java]  view plain  copy

1. package com.itlwc;  
2.   
3. import java.util.EnumMap;  
4. import java.util.Map;  
5.   
6. enum Color {  
7.     RED, GREEN, BLUE;  
8. }  
9.   
10. public class Test {  
11.     public static void main(String[] args) {  
12.         EnumMap<Color, String> eMap = new EnumMap<Color, String>(Color.class);  
13.         eMap.put(Color.RED, "红色");  
14.         eMap.put(Color.GREEN, "绿色");  
15.         eMap.put(Color.BLUE, "蓝色");  
16.         for (Map.Entry<Color, String> mapE : eMap.entrySet()) {  
17.             System.out.println(mapE.getKey() + "-->" + mapE.getValue());  
18.         }  
19.     }  
20. }  
21. /* 
22. 打印结果: 
23.     RED-->红色 
24.     GREEN-->绿色 
25.     BLUE-->蓝色 
26. */  

EnumSet对Enum的支持

allOf()静态内部方法,用来将全部内容设置到集合中

[java]  view plain  copy

1. package com.itlwc;  
2.   
3. import java.util.EnumSet;  
4. import java.util.Iterator;  
5.   
6. enum Color {  
7.     RED, GREEN, BLUE;  
8. }  
9.   
10. public class Test {  
11.     public static void main(String[] args) {  
12.         EnumSet<Color> eSet = EnumSet.allOf(Color.class);  
13.         Iterator<Color> iter = eSet.iterator();  
14.         while (iter.hasNext()) {  
15.             System.out.println(iter.next());  
16.         }  
17.     }  
18. }  
19. /* 
20. 打印结果: 
21.     RED 
22.     GREEN 
23.     BLUE 
24. */