enum

 

转自： http://blog.csdn.net/lz12366007/article/details/4729781

java枚举(enum)学习
来自:www.java1995.org　作者: 爪娃
2009-06-06 浏览(138) 评论(0) 发表评论
摘要: Java中的枚举是在JDK1.5才引进的，使用enum为关键字，是一种新的类型，允许用常量来表示数据片断。所有的枚举类型都是java.lang.Enum类的子类，枚举内的常量用‘，’分隔开，若后面还有语句，则最后一个常量后面要用‘；’，枚举...
Java中的枚举是在JDK1.5才引进的，使用enum为关键字，是一种新的类型，允许用常量来表示数据片断。所有的枚举类型都是java.lang.Enum类的子类，枚举内的常量用‘，’分隔开，若后面还有语句，则最后一个常量后面要用‘；’，枚举中的常量默认都是public static final，这就是为什么枚举中的常量建议全大写的原因，虽然它默认是public static final，但你在声明常量时却不能显式使用public static final，否则编译器反而会报错误。枚举常量实际就是格举类型的实例，它的初始化是依靠java.lang.Enum类的构造方法来的，见下：

Java代码
1.  // java.lang.Enum中定义的构造函数，
2.  // 两个参数分别是定义的枚举常量名称以及它所在的次序。
3.  protected Enum(String name, int ordinal) {
4.
5.    this.name = name;
6.
7.    this.ordinal = ordinal;
8.
9.  }

第一个枚举常量的值默认是0,其它的依次加1.
下面先看下简单的枚举类的定义：
Java代码
1.  public enum Colors{
2.     RED，BLUE，GREEN，YELLOW，GRAY;
3.     //GRAY后面若没有其它的语句，则其后面的分号可不写，若后面有语句则必须添加
4.  }

下面看个简单的应用：

Java代码
1.  package com.iwtxokhtd.enums;
2.
3.  /**
4.   * @author Administrator
5.   *
6.   */
7.  public enum Colors {
8.
9.      /**
10.      * 定义一个颜色枚举类
11.      */
12.     RED,
13.     GREEN,
14.     BLUE,
15.     YELLOW,
16.     GRAY;
17. }
18. /**
19.  * 测试枚举类型
20.  */
21. package com.iwtxokhtd.enums;
22.
23. /**
24.  * @author Administrator
25.  *
26.  */
27. public class EnumTest {
28.
29.     public static void printColor(Colors color){
30.         //用switch，在jdk1.5以后其参数支持enum，而不仅仅是int,short,char,byte
31.         switch(color){
32.         case RED:
33.             System.out.println("这是红色");
34.             break;
35.         case GREEN:
36.             System.out.println("这是绿色");
37.             break;
38.         case BLUE:
39.             System.out.println("这是蓝色");
40.             break;
41.         case YELLOW:
42.             System.out.println("这是黄色");
43.             break;
44.         case GRAY:
45.             System.out.println("这是灰色");
46.             break;
47.             default:
48.                 System.out.println("其它色");
49.         }
50.     }
51.     public static void main(String []args){
52.         //打印蓝色
53.         printColor(Colors.BLUE);
54.     }
55. }


使用EnumMap
EnumMap是为枚举类型定做的Map实现，它比其它的Map实现能更高效地完成枚举类型实例到值的映射，EnumMap内部使用枚举类型的ordinal()方法得到当前实例的声明次序。
见示例：

Java代码
1.  /**
2.   * EnumMap测试
3.   */
4.  package com.iwtxokhtd.enums;
5.
6.  import java.util.EnumMap;
7.
8.  /**
9.   * @author Administrator
10.  *
11.  */
12. public class EnumMapTest {
13.
14.     private  EnumMap<Colors,String> colors=new EnumMap<Colors,String>(Colors.class);
15.     public EnumMapTest(){
16.         colors.put(Colors.RED, "红色");
17.         colors.put(Colors.BLUE, "蓝色");
18.         colors.put(Colors.GRAY, "灰色");
19.         colors.put(Colors.GREEN, "绿色");
20.         colors.put(Colors.YELLOW, "黄色");
21.     }
22.     //取得颜色
23.     public  String getColor(Colors color){
24.         return  colors.get(color);
25.     }
26.     public static void main(String []args){
27.         System.out.println(new EnumMapTest().getColor(Colors.BLUE));
28.     }
29.
30. }

枚举其实是个类，下面来看看枚举作为一个类的使用：

下面我们将以前的那些类定义放到一个类中，见代码：


Java代码
1.  /**
2.   * 枚举改造
3.   */
4.  package com.iwtxokhtd.enums;
5.
6.  import java.util.EnumSet;
7.
8.  /**
9.   * @author Administrator
10.  *
11.  */
12. enum AnotherColors{
13.     RED,GREEN,BLUE,YELLOW,GRAY;
14.     public  String  printColor(){
15.         switch(this){
16.         case RED:
17.             return "这是红色";
18.         case GREEN:
19.             return "这是绿色";
20.         case BLUE:
21.             return "这是蓝色";
22.         case YELLOW:
23.             return "这是黄色";
24.         case GRAY:
25.             return "这是灰色";
26.         default:
27.             return "其它色";
28.         }
29.     }
30. }
31. public class OneClassTest {
32.
33.     public static void main(String []args){
34.         //EnumSet.allOf()是指以AnotherColors的全部变量为Set的值，详情见JDK文档
35.         for(AnotherColors color:EnumSet.allOf(AnotherColors.class)){
36.             System.out.println("定义的颜色信息是："+color.printColor());
37.
38.         }
39.     }
40. }

枚举类型也允许定义自己的构造方法如：

Java代码
1.  /**
2.   * 枚举类型允许定义自己的构造方法
3.   */
4.  package com.iwtxokhtd.enums;
5.
6.  import java.util.EnumSet;
7.
8.  /**
9.   * @author Administrator
10.  *
11.  */
12. enum ConstructorEnum{
13.     RED("red","红色"),
14.     GREEN("green","绿色"),
15.     BLUE("blue","蓝色"),
16.     YELLOW("yellow","黄色"),
17.     GRAY("gray","灰色");
18.
19.     //枚举类的字段或属性必须定义在枚举常量的后面
20.     private String color;
21.     private String message;
22.     //默认是private型
23.     ConstructorEnum(String color,String message){
24.
25.         this.color=color;
26.         this.message=message;
27.     }
28.     public String getColor() {
29.         return color;
30.     }
31.     public String getMessage() {
32.         return message;
33.     }
34. }
35. public class NewEnumTest {
36.
37.     public static void main(String []args){
38.         for(ConstructorEnum color:EnumSet.allOf(ConstructorEnum.class)){
39.             System.out.println("颜色键为："+color.getColor());
40.             System.out.println("颜色值为："+color.getMessage());
41.         }
42.     }
43. }



使用枚举类型注意事项：
(1) 枚举类型不能使用extends关键字，但是可以使用implements关键字。这样我们可以把不同枚举类型共有的行为提取到接口中，来规范枚举类型的行为。
(2) 枚举类型的自定义构造函数并不能覆盖默认执行的构造函数，它会跟在默认构造函数之后执行。
(3) 枚举类型的自定义构造函数必须是私有的，但你不能显式加private，否则会出错
 (4)枚举类型中枚举常量的定义必须放在最上面，其后才能是变量和方法的定义。

下面学下枚举类的自定义方法，见代码：


Java代码
1.  /**
2.   * 在枚举类里使用自定义方法
3.   */
4.  package com.iwtxokhtd.enums;
5.
6.  import java.util.EnumSet;
7.
8.  /**
9.   * @author Administrator
10.  *
11.  */
12. enum MethodEnum{
13.     RED{
14.         public void printColor(){
15.             System.out.println("红色");
16.         }
17.     },
18.
19.     GREEN{
20.         public void printColor(){
21.             System.out.println("绿色");
22.         }
23.     },
24.
25.     BLUE{
26.         public void printColor(){
27.             System.out.println("蓝色");
28.         }
29.     },
30.
31.     YELLOW{
32.         public void printColor(){
33.             System.out.println("黄色");
34.         }
35.     },
36.
37.     GRAY{
38.         public void printColor(){
39.             System.out.println("灰色");
40.         }
41.     };
42.     public  abstract void printColor();
43. }
44. public  class MethodEnumTest {
45.
46.     //测试使用自定义的方法来打印枚举类的常量值
47.     public static void main(String []args){
48.         for(MethodEnum color:EnumSet.allOf(MethodEnum.class)){
49.             color.printColor();
50.         }
51.     }
52. }


下面来看下，如何通过相关的数据反过来查找枚举类中的项，解释见下面的代码：
Java代码
1.  /**
2.   * 通过相关的数据来查找对应的枚举项
3.   */
4.  package com.iwtxokhtd.enums;
5.
6.  import java.util.EnumSet;
7.  import java.util.HashMap;
8.  import java.util.Map;
9.
10. /**
11.  * @author Administrator
12.  *
13.  */
14. enum SearchEnum{
15.     RED(0),
16.     GREEN(1),
17.     BLUE(2),
18.     YELLOW(3),
19.     GRAY(4);
20.     //使用静态的Map把相关的数据与枚举项关联起来
21.     private static final Map<Integer,SearchEnum> search=new HashMap<Integer,SearchEnum>();
22.     //把有的关联项放到Map里
23.     static{
24.         for(SearchEnum color:EnumSet.allOf(SearchEnum.class)){
25.             search.put(color.getI(), color);
26.         }
27.     }
28.     private int i;
29.     SearchEnum(int i){
30.         this.i=i;
31.     }
32.     public int getI(){
33.         return i;
34.     }
35.     //查找
36.     public static SearchEnum get(int i){
37.         return search.get(i);
38.     }
39. }
40. public class SearchEnumTest {
41.     //测试查找
42.     public static void main(String []args){
43.         //查找BLUE
44.         System.out.println(SearchEnum.get(2));
45.     }
46. }

枚举的学习先到这里，注意：枚举在某些场合使用还是比较方便的，如：定义时间日期常量、颜色常量、身高离散常量、物品的尺寸等，但千万不要滥用。