Java5 枚举类型使用总结

Java5 枚举类型使用总结

 

一、概述

枚举（enum）类型是Java 5新增的特性，它是一种新的类型，允许用常量来表示特定的数据片断，而且全部都以类型安全的形式来表示。Tiger 专家、developerWorks 的多产作者 Brett McLaughlin 将解释枚举的定义，介绍如何在应用程序中运用枚举，以及它为什么能够让您抛弃所有旧的 public static final 代码。

 

枚举在什么地方适用呢？一条普遍规则是，任何使用常量的地方，例如目前用 switch 代码切换常量的地方。如果只有单独一个值（例如，鞋的最大尺寸，或者笼子中能装猴子的最大数目），则还是把这个任务留给常量吧。但是，如果定义了一组值，而这些值中的任何一个都可以用于特定的数据类型，那么将枚举用在这个地方最适合不过。

 

二、在枚举类型之前，Java是如何实现枚举功能的

在枚举类型出现之前，java是通过在接口或者类中定义public static final 的变量来实现的。比如，对于经典的红色警戒2中的英国狙击（sharp-shooter）手三个动作的描述：

 

 
public  interface  SharpShooter_1 { 
        public  static  final  int  LOCKED = 1;          //锁定 
        public  static  final  int  AIM = 2;                //瞄准 
        public  static  final  int  SHOOT = 3;            //射击 
} 

 

 
public  class  TestDemo_1 { 
        public  static  void  main(String args[]) { 
                TestDemo_1 test =  new  TestDemo_1(); 
                test.doAction(1); 
                test.doAction(2); 
                test.doAction(3); 
                test.doAction(4); 
        } 

         
        public  void  doAction( int  action) { 
                switch  (action) { 
                        case  SharpShooter_1.LOCKED: 
                                System.out.println( "1:锁定目标"); 
                                break; 
                        case  SharpShooter_1.AIM: 
                                System.out.println( "2:瞄准目标"); 
                                break; 
                        case  SharpShooter_1.SHOOT: 
                                System.out.println( "3:射击"); 
                                break; 
                        default: 
                                System.out.println( "×:游戏还没有定义此动作!"); 
                } 
        } 
} 

 

运行结果：

1:锁定目标
2:瞄准目标
3:射击
×:游戏还没有定义此动作!

 

[说明]:当然SharpShooter_1也可以声明为class，还可以直接将常量定义到TestDemo_1中，如果常量只是在类内部使用，就声明为private或者是protected，如果声明为public，则通常是与类功能相联系的常数。

 

[注意]:switch语句的条件只能接收数值或字符(byte、short、int或char)或枚举(enum)类型的变量名或表达式。如果没有符合条件数值或字符，则执行default语句，default语句不是必须的，如果没有默认要处理的动作，则default语句可省略。break语句的作用是跳出循环块。

三、枚举类型的等价实现

 

 
public  enum  SharpShooter_2 { 
        LOCKED, 
        AIM, 
        SHOOT 
} 

 

 
public  class  TestDemo_2 { 

        public  static  void  main(String args[]){ 
                TestDemo_2 test= new  TestDemo_2(); 
                test.doAction(SharpShooter_2.LOCKED); 
                test.doAction(SharpShooter_2.AIM); 
                test.doAction(SharpShooter_2.SHOOT); 
        } 
         
        public  void  doAction(SharpShooter_2 action) { 
                switch  (action) { 
                        case  LOCKED: 
                                System.out.println( "1:锁定目标"); 
                                break; 
                        case  AIM: 
                                System.out.println( "2:瞄准目标"); 
                                break; 
                        case  SHOOT: 
                                System.out.println( "3:射击"); 
                                break; 
                        default: 
                                System.out.println( "×:游戏还没有定义此动作!"); 
                } 
        } 
} 

 

运行结果：

 

1:锁定目标
2:瞄准目标
3:射击

 

三、枚举类型的实质

 

在编译SharpShooter_2.java后，会生成一个SharpShooter_2.class文件，这说明枚举类型的实质还是一个类。因此，在某种程度上，enum关键字的作用就是class或者interface。

 

当使用enum定义一个枚举类型时，实际上所定义的类型自动继承了java.lang.Enum类。而每个被枚举的成员实质就是一个枚举类型的实例，他们默认都是public static final的。可以直接通过枚举类型名直接使用它们。

 

在查询JDK1.5文档的java.lang.Enum类，里面清楚的说明：java.lang.Enum类是所有 Java 语言枚举类型的公共基本类。因此，所有枚举类型都拥有有java.lang.Enum类所提供的共有方法。因此，要学会使用枚举，还必须认识java.lang.Enum类。下面将详细说明。

 

四、java.lang.Enum类

 

public abstract class Enum>extends Objectimplements Comparable, Serializable这是所有 Java 语言枚举类型的公共基本类。

 

－－－－－－－－－－－－－－－－－－

构造方法摘要

protected Enum(String name,int ordinal)

      单独的构造方法。程序员无法调用此构造方法。该构造方法用于由响应枚举类型声明的编译器发出的代码。

 

      参数：

      name - - 此枚举常量的名称，它是用来声明该常量的标识符。

      ordinal - - 枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。

 

－－－－－－－－－－－－－－－－－－

方法摘要

 

protected  Object clone()

                  抛出 CloneNotSupportedExcepti on。

 

  int compareTo(E o)

                  比较此枚举与指定对象的顺序。在该对象小于、等于或大于指定对象时，分别返回负整数、零或正整数。 枚举常量只能与相同枚举类型的其他枚举常量进行比较。该方法实现的自然顺序就是声明常量的顺序。 

 

  boolean equals(Object other)

                  当指定对象等于此枚举常量时，返回 true。

 

  Class getDeclaringClass()

                  返回与此枚举常量的枚举类型相对应的 Class 对象。当且仅当 e1.getDeclaringClass() == e2.getDeclaringClass() 时，两个枚举常量 e1 和 e2 的枚举类型才相同。（由该方法返回的值不同于由 Object.getClass() 方法返回的值，Object.getClass() 方法用于带有特定常量的类主体的枚举常量。） 

 

  int hashCode()

                  返回枚举常量的哈希码。

 

  String name()

                  返回此枚举常量的名称，在其枚举声明中对其进行声明。 与此方法相比，大多数程序员应该优先考虑使用 toString() 方法，因为 toString 方法返回更加用户友好的名称。该方法主要设计用于特殊情形，其正确性取决于获得正确的名称，其名称不会随版本的改变而改变

 

  int ordinal()

                  返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。 大多数程序员不会使用此方法。它被设计用于复杂的基于枚举的数据结构，比如 EnumSet 和 EnumMap。 

 

  String toString()

                  返回枚举常量的名称，它包含在声明中。

 

public static > T valueOf(Class enumType, String name)

                  返回带指定名称的指定枚举类型的枚举常量。名称必须与在此类型中声明枚举常量所用的标识符完全匹配。（不允许使用额外的空白字符。）

 

    参数：

    enumType - 要从中返回常量的枚举类型的 Class 对象

    name - 要返回的常量名称 

 

注意：ordinal() 方法得到枚举顺序的索引，默认从0开始。

 

五、枚举的高级用法

 

1、枚举方法

 

既然枚举的本质是类，那么定义枚举类型时也可以定义方法。比如：

 

 
public  enum  SharpShooter_3 { 
        LOCKED, 
        AIM, 
        SHOOT; 

        public  String getDesc() { 
                switch  ( this.ordinal()) { 
                        case  0: 
                                return  "锁定目标"; 
                        case  1: 
                                return  "瞄准目标"; 
                        case  2: 
                                return  "射击"; 
                        default: 
                                return  "没有该枚举值！"; 
                } 
        } 
} 

 

 
public  class  TestDemo_3 { 
        public  static  void  main(String args[]) { 
                for  (SharpShooter_3 enumSS : SharpShooter_3.values()) { 
                        System.out.println(enumSS +  " "  + enumSS.getDesc()); 
                } 
        } 
}

 

运行结果：

LOCKED 锁定目标 
AIM 瞄准目标 
SHOOT 射击 

Process finished with exit code 0

 

 

2、枚举构造方法

 

 
public  enum  SharpShooter_4 { 
        LOCKED( "锁定目标"), 
        AIM( "瞄准目标"), 
        SHOOT( "射击"); 

        private  String desc;                //枚举说明 

         
        private  SharpShooter_4(String desc){ 
                this.desc=desc; 
        } 

         
        public  String getDesc(){ 
                return  desc; 
        } 
} 

 

 
public  class  TestDemo_4 { 
        public  static  void  main(String args[]) { 
                for  (SharpShooter_4 enumSS : SharpShooter_4.values()) { 
                        System.out.println(enumSS +  " "  + enumSS.getDesc()); 
                } 
        } 
}

 

运行结果：

LOCKED 锁定目标 
AIM 瞄准目标 
SHOOT 射击 

Process finished with exit code 0

 

3、实现接口的枚举

 

 
public  interface  IDesc { 
         
        public  String getDesc(); 
} 

 

 
public  enum  SharpShooter_5  implements  IDesc { 
        LOCKED( "锁定目标"), 
        AIM( "瞄准目标"), 
        SHOOT( "射击"); 

        private  String desc;                //枚举说明 

         
        private  SharpShooter_5(String desc) { 
                this.desc = desc; 
        } 

        public  String getDesc() { 
                return  desc; 
        } 
} 

 

 
public  class  TestDemo_5 { 
        public  static  void  main(String args[]) { 
                for  (SharpShooter_5 enumSS : SharpShooter_5.values()) { 
                        System.out.println(enumSS +  " "  + enumSS.getDesc()); 
                } 
        } 
} 

 

运行结果：

LOCKED 锁定目标 
AIM 瞄准目标 
SHOOT 射击 

Process finished with exit code 0 

4、每个枚举值实现的自己的接口

 

 
public  enum  SharpShooter_6  implements  IDesc { 
        LOCKED(){ 
                public  String getDesc() { 
                        return  "锁定目标"; 
                } 
        }, 

        AIM{ 
                public  String getDesc() { 
                        return  "瞄准目标"; 
                } 
        }, 

        SHOOT{ 
                public  String getDesc() { 
                        return  "射击"; 
                } 
        } 
} 

 

 
public  class  TestDemo_6 { 
        public  static  void  main(String args[]) { 
                for  (SharpShooter_6 enumSS : SharpShooter_6.values()) { 
                        System.out.println(enumSS +  " "  + enumSS.getDesc()); 
                } 
        } 
}

 

运行结果：

LOCKED 锁定目标 
AIM 瞄准目标 
SHOOT 射击 

Process finished with exit code 0

 

5、带有抽象方法的枚举类型

 

 
public  enum  SharpShooter_7 { 
        LOCKED(){ 
                public  String getDesc() { 
                        return  "锁定目标"; 
                } 
        }, 

        AIM{ 
                public  String getDesc() { 
                        return  "瞄准目标"; 
                } 
        }, 

        SHOOT{ 
                public  String getDesc() { 
                        return  "射击"; 
                } 
        }; 

         
        public  abstract  String getDesc(); 
}

 

 
public  class  TestDemo_7 { 
        public  static  void  main(String args[]) { 
                for  (SharpShooter_7 enumSS : SharpShooter_7.values()) { 
                        System.out.println(enumSS +  " "  + enumSS.getDesc()); 
                } 
        } 
}

 

运行结果：

LOCKED 锁定目标 
AIM 瞄准目标 
SHOOT 射击 

Process finished with exit code 0 

 

六、对Java枚举类型的一些看法

 

枚举的本质是类，在没有枚举之前，仍然可以按照java最基本的编程手段来解决需要用到枚举的地方。枚举屏蔽了枚举值的类型信息，不像在用public static final定义变量必须指定类型。枚举是用来构建常量数据结构的模板，这个模板可扩展。枚举的使用增强了程序的健壮性，比如在引用一个不存在的枚举值的时候，编译器会报错。枚举的更多用法还需要在开发中去研究创造，Java5、Java6增加了不少新的特性，技术在升级，对程序员来说就要学习，如果你热爱java的话。否则别人用到新特性的代码你看不懂，那才叫郁闷。

 

目前，本人在开发中也很少用到枚举，虽然Java设计得很好，处心积虑为开发人员着想，但是是否有必要增加一个关键字让全世界的java程序员去学习研究？本人感觉Java现在越来越复杂了，新特性对我而言是一大障碍，需要大量的时间去熟悉？对此，我也不敢妄下结论，一是我们和java科学家差距太大，二是怕误导读者，这个就留个各位读者吧！