`

java中的枚举详解

    博客分类:
  • java
 
阅读更多

您已经知道,Java 代码的两个基本的构造块是 和 接口。现在 Tiger 又引入了 枚举,一般简称它为 enum。这个新类型允许您表示特定的数据点,这些数据点只接受分配时预先定义的值集合。

当然,熟练的程序员可以用静态常量实现这项功能,如清单 1 所示:


清单 1. public static final 的常量
public class OldGrade {
  public static final int A = 1;
  public static final int B = 2;
  public static final int C = 3;
  public static final int D = 4;
  public static final int F = 5;
  public static final int INCOMPLETE = 6;
}

说明:我要感谢 O'Reilly 媒体公司,该公司允许在本文中使用我撰写的 Java 1.5 Tiger: A Developer's Notebook一书中“枚举”这一章中的代码示例(请参阅 参考资料)。

然后您就可以让类接受像 OldGrade.B 这样的常量,但是在这样做的时候,请记住这类常量是 Java 中 int 类型的常量,这意味着该方法可以接受任何 int 类型的值,即使它和 OldGrade 中定义的所有级别都不对应。因此,您需要检测上界和下界,在出现无效值的时候,可能还要包含一个 IllegalArgumentException 。而且,如果后来又添加另外一个级别(例如 OldGrade.WITHDREW_PASSING ),那么必须改变所有代码中的上界,才能接受这个新值。

换句话说,在使用这类带有整型常量的类时,该解决方案也许可行,但并不是非常有效。幸运的是,枚举提供了更好的方法。

定义枚举

清单 2 使用了一个可以提供与清单 1 相似的功能的枚举:


清单 2. 简单的枚举类型
package com.oreilly.tiger.ch03;
public enum Grade {
  A, B, C, D, F, INCOMPLETE
};

在这里,我使用了新的关键字 enum ,为 enum 提供了一个名称,并指定了允许的值。然后, Grade 就变成了一个 枚举类型,您可以按清单 3 所示的方法使用它:


清单 3. 使用枚举类型
package com.oreilly.tiger.ch03;
public class Student {
  private String firstName;
  private String lastName;
  private Grade grade;
  public Student(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }
  public void setFirstName(String firstName) {
    this.firstName = firstName;
  }
  public String getFirstName() {
    return firstName;
  }
  public void setLastName(String lastName) {
    this.lastName = lastName;
  }
  public String getLastName() {
    return lastName;
  }
  public String getFullName() {
    return new StringBuffer(firstName)
           .append(" ")
           .append(lastName)
           .toString();
  }
  public void assignGrade(Grade grade) {
    this.grade = grade;
  }
  public Grade getGrade() {
    return grade;
  }
}

用以前定义过的类型建立一个新的枚举( grade )之后,您就可以像使用其他成员变量一样使用它了。当然,枚举只能分配枚举值中的一个(例如, A 、 C 或 INCOMPLETE )。而且,在 assignGrade() 中是没有进行错误检测的代码,也没有考虑边界情况,请注意这是如何做到。

使用枚举值

迄今为止,您所看到的示例都相当简单,但是枚举类型提供的东西远不止这些。您可以逐个遍历枚举值,也可以在 switch 语句中使用枚举值,枚举是非常有价值的。

遍历枚举值

下面我们用一个示例显示如何遍历枚举类型的值。清单 4 所示的这项技术,适用于调试、快速打印任务以及把枚举加载到集合(我很快将谈到)中的工具:


清单 4. 遍历枚举值
public void listGradeValues(PrintStream out) throws IOException {
  for (Grade g : Grade.values()) {
    out.println("Allowed value: '" + g + "'");
  }
}

运行这段代码,将得到清单 5 所示的输出:


清单 5. 迭代操作的输出
Allowed Value: 'A'
Allowed Value: 'B'
Allowed Value: 'C'
Allowed Value: 'D'
Allowed Value: 'F'
Allowed Value: 'INCOMPLETE'

这里有许多东西。首先,我使用了 Tiger 的新的 for/in 循环(也叫作 foreach 或 增强的 for )。另外,您可以看到 values() 方法返回了一个由独立的 Grade 实例构成的数组,每个数组都有一个枚举类型的值。换句话说, values() 的返回值是 Grade[] 。

在枚举间切换

能够在枚举的值之间移动很好,但是更重要的是根据枚举的值进行决策。您当然可以写一堆 if (grade.equals(Grade.A)) 类型的语句,但那是在浪费时间。Tiger 能够很方便地把枚举支持添加到过去的好东西 switch 语句上,所以它很容易使用,而且适合您已知的内容。清单 6 向将展示如何解决这个难题:


清单 6. 在枚举之间切换
public void testSwitchStatement(PrintStream out) throws IOException {
  StringBuffer outputText = new StringBuffer(student1.getFullName());
  switch (student1.getGrade()) {
    case A: 
      outputText.append(" excelled with a grade of A");
      break;   
    case B: // fall through to C
    case C: 
      outputText.append(" passed with a grade of ")
                .append(student1.getGrade().toString());
      break;
    case D: // fall through to F
    case F:
      outputText.append(" failed with a grade of ")
                .append(student1.getGrade().toString());
      break;
    case INCOMPLETE:
      outputText.append(" did not complete the class.");
      break;
  }
  out.println(outputText.toString());
}

在这里,枚举值被传递到 switch 语句中(请记住, getGrade() 是作为 Grade 的实例返回的),而每个 case 子句将处理一个特定的值。该值在提供时没有枚举前缀,这意味着不用将代码写成 case Grade.A ,只需将其写成 case A 即可。如果您不这么做,编译器不会接受有前缀的值。

现在,您应该已经了解使用 switch 语句时的基本语法,但是还有一些事情您需要知道。

在使用 switch 之前进行计划

正如您所期待的,在使用枚举和 switch 时,您可以使用 default 语句。清单 7 显示了这个用法:


清单 7. 添加一个 default 块
public void testSwitchStatement(PrintStream out) throws IOException {
  StringBuffer outputText = new StringBuffer(student1.getFullName());
  switch (student1.getGrade()) {
    case A: 
      outputText.append(" excelled with a grade of A");
      break;   
    case B: // fall through to C
    case C: 
      outputText.append(" passed with a grade of ")
                .append(student1.getGrade().toString());
      break;
    case D: // fall through to F
    case F:
      outputText.append(" failed with a grade of ")
                .append(student1.getGrade().toString());
      break;
    case INCOMPLETE:
      outputText.append(" did not complete the class.");
      break;
    
        default:
      outputText.append(" has a grade of ")
                .append(student1.getGrade().toString());
      break;
  }
  out.println(outputText.toString());
}
      

研究以上代码可以看出,任何没有被 case 语句处理的枚举值都会被 default 语句处理。这项技术您应当 坚持采用。原因是:假设Grade 枚举被您的小组中其他程序员修改(而且他忘记告诉您这件事)成清单 8 所示的版本:


清单 8. 给 Grade 枚举添加一个值
package com.oreilly.tiger.ch03;
public enum Grade {
  A, B, C, D, F, INCOMPLETE
        , 
  WITHDREW_PASSING, WITHDREW_FAILING
};
      

现在,如果使用清单 6 的代码所示的新版 Grade ,那么这两个新值会被忽略。更糟的是,您甚至看不到错误!在这种情况下,存在某种能够通用的 default 语句是非常重要的。清单 7 无法很好地处理这些值,但是它会提示您还有其他值,您需要处理这些值。一旦完成处理,您就会有一个继续运行的应用程序,而且它不会忽略这些值,甚至还会指导您下一步的动作。所以这是一个良好的编码习惯。

枚举和集合

您所熟悉的使用 public static final 方法进行编码的那些东西,可能已经转而采用枚举的值作为映射的键。如果您不知道其中的含义,请参见清单 9,它是一个公共错误信息的示例,在使用 Ant 的 build 文件时,可能会弹出这样的消息,如下所示:


清单 9. Ant 状态码
package com.oreilly.tiger.ch03;
public enum AntStatus {
  INITIALIZING,
  COMPILING,
  COPYING,
  JARRING,
  ZIPPING,
  DONE,
  ERROR
}

为每个状态码分配一些人们能读懂的错误信息,从而允许人们在 Ant 提供某个代码时查找合适的错误信息,将这些信息显示在控制台上。这是 映射(Map) 的一个绝好用例,在这里,每个 映射(Map) 的键都是一个枚举值,而每个值都是键的错误信息。清单 10 演示了该映射的工作方式:


清单 10. 枚举的映射(Map)
public void testEnumMap(PrintStream out) throws IOException {
  // Create a map with the key and a String message
  EnumMap<AntStatus, String> antMessages =
    new EnumMap<AntStatus, String>(AntStatus.class);
  // Initialize the map
  antMessages.put(AntStatus.INITIALIZING, "Initializing Ant...");
  antMessages.put(AntStatus.COMPILING,    "Compiling Java classes...");
  antMessages.put(AntStatus.COPYING,      "Copying files...");
  antMessages.put(AntStatus.JARRING,      "JARring up files...");
  antMessages.put(AntStatus.ZIPPING,      "ZIPping up files...");
  antMessages.put(AntStatus.DONE,         "Build complete.");
  antMessages.put(AntStatus.ERROR,        "Error occurred.");
  // Iterate and print messages
  for (AntStatus status : AntStatus.values() ) {
    out.println("For status " + status + ", message is: " +
                antMessages.get(status));
  }
}

该代码使用了泛型(generics)(请参阅 参考资料)和新的 EnumMap 构造来建立新映射。而且,枚举值是通过其 Class 对象提供的,同时提供的还有映射值的类型(在该例中,它只是一个简单的字符串)。该方法的输出如清单 11 所示:

枚举的 Class 对象?

您可能已经注意到,清单 10 中的示例代码实际上表明 Tiger 把枚举当作类,这可以从 AntStatus 的 Class 对象那里得到证明,该对象不仅可用,而且正被实际使用。这是真的。归根到底, Tiger 还是把枚举看成是特殊的类类型。有关枚举的具体实现细节,请参阅 Java 5.0 Tiger: A Developer's Notebook的第三章(请参阅 参考资料)。


清单 11. 清单 10 的输出
[echo] Running AntStatusTester...
[java] For status INITIALIZING, message is: Initializing Ant...
[java] For status COMPILING, message is: Compiling Java classes...
[java] For status COPYING, message is: Copying files...
[java] For status JARRING, message is: JARring up files...
[java] For status ZIPPING, message is: ZIPping up files...
[java] For status DONE, message is: Build complete.
[java] For status ERROR, message is: Error occurred.

更进一步

枚举也可以与集合结合使用,而且非常像新的 EnumMap 构造,Tiger 提供了一套新的 EnumSet 实现,允许您使用位操作符。另外,可以为枚举添加方法,用它们实现接口,定义叫作 特定值的类的实体,在该实体中,特定的代码被附加到枚举的具体值上。这些特性超出了本文的范围,但是在其他地方,有详细介绍它们的文档(请参阅 参考资料)。

使用枚举,但是不要滥用

学习任何新版语言的一个危险就是疯狂使用新的语法结构。如果这样做,那么您的代码就会突然之间有 80% 是泛型、标注和枚举。所以,应当只在适合使用枚举的地方才使用它。那么,枚举在什么地方适用呢?一条普遍规则是,任何使用常量的地方,例如目前用switch 代码切换常量的地方。如果只有单独一个值(例如,鞋的最大尺寸,或者笼子中能装猴子的最大数目),则还是把这个任务留给常量吧。但是,如果定义了一组值,而这些值中的任何一个都可以用于特定的数据类型,那么将枚举用在这个地方最适合不过。

 

----------------------------------------------------------------------------------------------------------------------------------

----------------------------------------------------------------------------------------------------------------------------------

 

----------------------------------------------------------------------------------------------------------------------------------

枚举其实就是一种类型,跟int, char 这种差不多,就是定义变量时限制输入的,你只能够赋enum里面规定的值 。

枚举类型是JDK5.0的新特征  。Sun引进了一个全新的关键字enum来定义一个枚举类  。下面就是一个典型枚举类型的定义:

Java代码:

  1. public enum Color{  
  2. RED,BLUE,BLACK,YELLOW,GREEN  

 

显然,enum很像特殊的class,实际上enum声明定义的类型就是一个类  。 而这些类都是类库中Enum类的子类(java.lang.Enum)  。它们继承了这个Enum中的许多有用的方法  。我们对代码编译之后发现,编译器将enum类型单独编译成了一个字节码文件:Color.class  。

Color字节码代码

  1. final enum hr.test.Color {  
  2. // 所有的枚举值都是类静态常量  
  3. public static final enum hr.test.Color RED;  
  4. public static final enum hr.test.Color BLUE;  
  5. public static final enum hr.test.Color BLACK;  
  6. public static final enum hr.test.Color YELLOW;  
  7. public static final enum hr.test.Color GREEN;  
  8. private static final synthetic hr.test.Color[] ENUM$VALUES;  
  9. // 初始化过程,对枚举类的所有枚举值对象进行第一次初始化  
  10. static {  
  11. 0 new hr.test.Color [1]  
  12. 3 dup  
  13. 4 ldc [16] //把枚举值字符串“RED”压入操作数栈  
  14. 6 iconst_0 // 把整型值0压入操作数栈  
  15. 7 invokespecial hr.test.Color(java.lang.String, int) [17] //调用Color类的私有构造器创建Color对象RED  
  16. 10 putstatic hr.test.Color.RED : hr.test.Color [21] //将枚举对象赋给Color的静态常量RED  。  
  17.   。..  。..  。.. 枚举对象BLUE等与上同  
  18. 102 return 
  19. };  
  20. // 私有构造器,外部不可能动态创建一个枚举类对象(也就是不可能动态创建一个枚举值)  。  
  21. private Color(java.lang.String arg0, int arg1){  
  22. // 调用父类Enum的受保护构造器创建一个枚举对象  
  23. 3 invokespecial java.lang.Enum(java.lang.String, int) [38]  
  24. };  
  25. public static hr.test.Color[] values();  
  26. // 实现Enum类的抽象方法  
  27. public static hr.test.Color valueOf(java.lang.String arg0);  

 

下面我们就详细介绍enum定义的枚举类的特征及其用法  。(后面均用Color举例)

1、Color枚举类就是class,而且是一个不可以被继承的final类  。

其枚举值(RED,BLUE.  。.)都是Color类型的类静态常量, 我们可以通过下面的方式来得到Color枚举类的一个实例:

  1. Color c=Color.RED; 

 

注意:这些枚举值都是public static final的,也就是我们经常所定义的常量方式,因此枚举类中的枚举值最好全部大写  。

2、即然枚举类是class,当然在枚举类型中有构造器,方法和数据域  。

但是,枚举类的构造器有很大的不同:

(1) 构造器只是在构造枚举值的时候被调用  。

Java代码:

  1. enum Color{  
  2. RED(25500),BLUE(00255),BLACK(000),YELLOW(2552550),GREEN(02550);  
  3. //构造枚举值,比如RED(255,0,0)  
  4. private Color(int rv,int gv,int bv){  
  5. this.redValue=rv;  
  6. this.greenValue=gv;  
  7. this.blueValue=bv;  
  8. }  
  9. public String toString(){ //覆盖了父类Enum的toString()  
  10. return super.toString()+“(”+redValue+“,”+greenValue+“,”+blueValue+“)”;  
  11. }  
  12. private int redValue; //自定义数据域,private为了封装  。  
  13. private int greenValue;  
  14. private int blueValue;  

(2) 构造器只能私有private,绝对不允许有public构造器  。 这样可以保证外部代码无法新构造枚举类的实例  。这也是完全符合情理的,因为我们知道枚举值是public static final的常量而已  。 但枚举类的方法和数据域可以允许外部访问  。

Java代码:

  1. public static void main(String args[])  
  2. {  
  3. // Color colors=new Color(100,200,300); //wrong  
  4. Color color=Color.RED;  
  5. System.out.println(color); // 调用了toString()方法  

 

3、所有枚举类都继承了Enum的方法,下面我们详细介绍这些方法  。

(1) ordinal()方法: 返回枚举值在枚举类种的顺序  。这个顺序根据枚举值声明的顺序而定  。

  1. Color.RED.ordinal(); //返回结果:0  
  2. Color.BLUE.ordinal(); //返回结果:1 

 

(2) compareTo()方法: Enum实现了java.lang.Comparable接口,因此可以比较象与指定对象的顺序  。Enum中的compareTo返回的是两个枚举值的顺序之差  。当然,前提是两个枚举值必须属于同一个枚举类,否则会抛出ClassCastException()异常  。(具体可见源代码)

  1. Color.RED.compareTo(Color.BLUE); //返回结果 -1 

 

(3) values()方法: 静态方法,返回一个包含全部枚举值的数组  。

  1. Color[] colors=Color.values();  
  2. for(Color c:colors){  
  3. System.out.print(c+“,”);  
  4. }//返回结果:RED,BLUE,BLACK YELLOW,GREEN, 

 

(4) toString()方法: 返回枚举常量的名称  。

  1. Color c=Color.RED;  
  2. System.out.println(c);//返回结果: RED 

 

(5) valueOf()方法: 这个方法和toString方法是相对应的,返回带指定名称的指定枚举类型的枚举常量  。

  1. Color.valueOf(“BLUE”); //返回结果: Color.BLUE 

 

(6) equals()方法: 比较两个枚举类对象的引用  。

Java代码:

  1. //JDK源代码:  
  2. public final boolean equals(Object other) {  
  3. return this==other;  

4、枚举类可以在switch语句中使用  。

Java代码:

  1. Color color=Color.RED;  
  2. switch(color){  
  3. case RED: System.out.println(“it‘s red”);break;  
  4. case BLUE: System.out.println(“it’s blue”);break;  
  5. case BLACK: System.out.println(“it‘s blue”);break;  

希望通过本文对java中枚举的介绍,能够给你到来帮助  。

分享到:
评论

相关推荐

    高阶Java-Java枚举类型 enum 应用详解

    本篇文章将深入探讨Java枚举的特性、用法以及如何在实际开发中充分利用它们。 一、枚举的基本用法 1. 声明枚举类型: ```java public enum Color { RED, GREEN, BLUE } ``` 在这里,`Color`是枚举类型,`RED`, `...

    Java枚举类型.pdf

    在本文中,我们将深入探讨Java枚举的定义、使用方法以及它如何改善传统使用`static final`常量的模式。 首先,让我们看看传统的`static final`常量表示枚举的方式。例如,清单1展示了如何使用`public static final`...

    JAVA枚举类型的用法详解

    下面我们将深入探讨Java枚举类型的常见用法。 首先,枚举类型在本质上等同于定义了一组静态常量。创建枚举类型的语法如下: ```java public enum Belle { para1, para2, para3, para4; } ``` 这会创建一个名为`...

    java枚举类型说明

    ### Java枚举类型详解 #### 一、引言 在Java编程语言中,枚举(Enum)作为一种重要的数据类型,在程序设计中扮演着不可或缺的角色。本文将深入探讨Java枚举类型的特性和用法,并通过具体实例说明其优势所在。枚举...

    Java2编程详解(Special_Edition_Using_Java)

    最后,本书可能还会涉及Java的最新特性,比如注解、泛型、枚举、动态代理等,这些都是Java语言不断演进的体现,有助于开发者保持与时俱进。 通过阅读《Java2编程详解》,无论是初学者还是有经验的开发者,都能从中...

    Java中的“枚举类型

    ### Java中的“枚举类型”知识点详解 #### 一、引言 在Java编程语言中,枚举(Enum)作为一种特殊的类,其设计初衷是为了更好地处理一组固定不变的常量集合。相较于传统的使用`static final`字段来表示常量的做法...

    Java5 枚举类详解及实例代码

    Java 5 引入的枚举类型(enum)是面向对象编程中的一种重要特性,它为表示一组固定值提供了类型安全且强大的方式。在本文中,我们将深入探讨枚举类的概念、用法以及其与传统常量定义的区别。 1. 枚举类的定义与常量...

    Java2编程详解

    10. **Java高级特性**:包括反射、动态代理、注解、枚举、集合工厂方法、泛型等,这些都是Java2平台的进阶特性,它们极大地增强了Java的灵活性和可维护性。 通过阅读《Java2编程详解》,读者可以系统地学习和掌握...

    Java中枚举类型的使用.docx

    ### Java中枚举类型的使用详解 #### 一、引言 在软件开发过程中,经常会遇到需要定义一组固定的常量的情况,比如系统中的状态值、选项等。这些常量的定义方式直接影响到代码的可读性、可维护性和扩展性。在Java...

    java 中枚举类enum的values()方法的详解

    Java 中枚举类 enum 的 values() 方法详解 Java 中的枚举类 enum 是一种特殊的类,通过使用 enum 关键字来定义。枚举类 enum 中有一个特殊的方法,values(),这个方法可以将枚举类转换为一个枚举类型的数组。通过...

    列举java 枚举相关信息

    ### Java 枚举类型详解 #### 一、引言 ...通过以上的介绍,我们可以看到Java枚举类型不仅提供了类型安全的保障,还为开发者带来了极大的灵活性。合理地使用枚举类型,可以显著提高代码的质量和可维护性。

    java 设计模式详解

    Java设计模式详解涵盖了在Java编程中广泛使用的一些经典设计模式。这些模式不仅有助于提高代码的可读性、可维护性和可扩展性,还能促进团队之间的沟通与协作。下面,我们将深入探讨几个重要的Java设计模式。 1. ...

    详解java枚举用法及实例

    Java枚举是编程语言中一种特殊的类,用于定义一组预定义的常量。枚举在Java中的使用丰富了代码的可读性和安全性。本篇文章将详细介绍Java枚举的用法和实例。 一、枚举类型作为常量 在Java中,枚举可以用来创建一组...

    java2编程详解(special_edition_using_java)

    10. **Java的高级特性**:可能包含泛型、枚举、匿名内部类、Lambda表达式等Java 5及以后版本引入的新特性。 11. **Java EE基础**:对于J2EE部分,可能简单介绍Servlet、JSP、EJB等企业级开发的关键技术。 12. **...

    java 枚举(enum) 详解(学习资料)

    Java 枚举(enum)是 Java 语言中的一个重要特性,自 Java 5 开始引入。枚举用于定义一组相关的常量,这些常量通常代表一个有限的、预定义的值集合。枚举类是一种特殊的类,它具有以下特点: 1. **枚举类的声明**:...

    Java枚举与.net枚举区别详解

    Java枚举与.net枚举区别详解 Java枚举与.net枚举是两种不同的枚举实现方式,虽然它们都是用来定义一组named values的类型,但是在定义、实现和使用方面有很大的不同。 一、定义方式 在.net中,枚举的定义方式非常...

    java23中设计模式详解

    在Java中,可以使用枚举、双重检查锁定等方式实现。 2. **工厂模式**:为创建对象提供接口,让客户端避免与具体类直接交互,增加代码的灵活性。简单工厂、工厂方法和抽象工厂模式是其三种主要形式。 3. **抽象工厂...

    javaenum(枚举)使用详解+总结.pdf

    Java中的枚举(enum)是自JDK 1.5版本引入的一种强大的类型,它用于定义一组相关的常量。枚举在Java中被设计为一种特殊的类,它们默认继承自`java.lang.Enum`抽象类,并且是单继承的,这意味着它们无法再继承其他类...

    java枚举的一个例子

    ### Java枚举详解 在Java编程语言中,枚举(`enum`)是一种特殊的类,用于定义一组固定的常量值。这些常量值通常代表了一组预定义的选项或者状态,比如颜色、方向等。使用枚举可以提高代码的可读性和可维护性,并且...

    Java枚举类型enum的详解及使用

    Java 枚举类型 enum 的详解及使用 Java 枚举类型 enum 是 Java 语言中的一种特殊的数据类型,自从 JDK 1.5 引入枚举类型以来,它已经成为了 Java 程序员中的一种常用工具。本文将对 Java 枚举类型 enum 进行详解,...

Global site tag (gtag.js) - Google Analytics