java枚举类型入门

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

网站建设、网站设计,成都做网站公司-创新互联已向上千家企业提供了,网站设计,网站制作,网络营销等服务!设计与技术结合,多年网站推广经验,合理的价格为您打造企业品质网站。

您已经知道，Java 代码的两个基本的构造块是类 和接口。现在 Tiger 又引入了枚举，一般简称它为 enum。这个新类型允许您表示特定的数据点，这些数据点只接受分配时预先定 义的值集合。
当然，熟练的程序员可以用静态常量实现这项功能，如清单 1 所示：

清单 1. public static final

 
 
 
    
  
  
  
  1. public class OldGrade {  
    2. 
  
  
  
  2. public static final int A = 1;  
    3. 
  
  
  
  3. public static final int B = 2;  
    4. 
  
  
  
  4. public static final int C = 3;  
    5. 
  
  
  
  5. public static final int D = 4;  
    6. 
  
  
  
  6. public static final int F = 5;  
    7. 
  
  
  
  7. public static final int INCOMPLETE = 6;  
    8. 
  
  
  
  8. } 
    9.

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

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

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

定义枚举

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

清单 2. 简单的枚举类型

 
 
 
    
  
  
  
  1. package com.oreilly.tiger.ch03;  
    2. 
  
  
  
  2. public enum Grade   
    3. 
  
  
  
  3. {  
    4. 
  
  
  
  4. A, B, C, D, F, INCOMPLETE  
    5. 
  
  
  
  5. }; 
    6.

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

清单 3. 使用枚举类型

 
 
 
    
  
  
  
  1. package com.oreilly.tiger.ch03;  
    2. 
  
  
  
  2. public class Student {  
    3. 
  
  
  
  3. private String firstName;  
    4. 
  
  
  
  4. private String lastName;  
    5. 
  
  
  
  5. private Grade grade;  
    6. 
  
  
  
  6. public Student(String firstName, String lastName) {  
    7. 
  
  
  
  7. this.firstName = firstName;  
    8. 
  
  
  
  8. this.lastName = lastName;  
    9. 
  
  
  
  9. }  
    10. 
  
  
  
  10. public void setFirstName(String firstName) {  
    11. 
  
  
  
  11. this.firstName = firstName;  
    12. 
  
  
  
  12. }  
    13. 
  
  
  
  13. public String getFirstName() {  
    14. 
  
  
  
  14. return firstName;  
    15. 
  
  
  
  15. }  
    16. 
  
  
  
  16. public void setLastName(String lastName) {  
    17. 
  
  
  
  17. this.lastName = lastName;  
    18. 
  
  
  
  18. }  
    19. 
  
  
  
  19. public String getLastName() {  
    20. 
  
  
  
  20. return lastName;  
    21. 
  
  
  
  21. }  
    22. 
  
  
  
  22. public String getFullName() {  
    23. 
  
  
  
  23. return new StringBuffer(firstName)  
    24. 
  
  
  
  24. .append(" ")  
    25. 
  
  
  
  25. .append(lastName)  
    26. 
  
  
  
  26. .toString();  
    27. 
  
  
  
  27. }  
    28. 
  
  
  
  28. public void assignGrade(Grade grade) {  
    29. 
  
  
  
  29. this.grade = grade;  
    30. 
  
  
  
  30. }  
    31. 
  
  
  
  31. public Grade getGrade() {  
    32. 
  
  
  
  32. return grade;  
    33. 
  
  
  
  33. }  
    34. 
  
  
  
  34. } 
    35.

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

使用枚举值

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

遍历枚举值

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

清单 4. 遍历枚举值

 
 
 
    
  
  
  
  1. public void listGradeValues(PrintStream out) throws IOException {  
    2. 
  
  
  
  2. for (Grade g : Grade.values()) {  
    3. 
  
  
  
  3. out.println("Allowed value: '" + g + "'");  
    4. 
  
  
  
  4. }  
    5. 
  
  
  
  5. } 
    6.

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

清单 5. 迭代操作的输出

 
 
 
    
  
  
  
  1. Allowed Value: 'A'  
    2. 
  
  
  
  2. Allowed Value: 'B'  
    3. 
  
  
  
  3. Allowed Value: 'C'  
    4. 
  
  
  
  4. Allowed Value: 'D'  
    5. 
  
  
  
  5. Allowed Value: 'F'  
    6. 
  
  
  
  6. Allowed Value: 'INCOMPLETE' 
    7.

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

在枚举间切换

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

清单 6 向将展示如何解决这个难题：

清单 6. 在枚举之间切换

 
 
 
    
  
  
  
  1. public void testSwitchStatement(PrintStream out) throws IOException {  
    2. 
  
  
  
  2. StringBuffer outputText = new StringBuffer(student1.getFullName());  
    3. 
  
  
  
  3. switch (student1.getGrade()) {  
    4. 
  
  
  
  4. case A:  
    5. 
  
  
  
  5. outputText.append(" excelled with a grade of A");  
    6. 
  
  
  
  6. break;  
    7. 
  
  
  
  7. case B: // fall through to C  
    8. 
  
  
  
  8. case C:  
    9. 
  
  
  
  9. outputText.append(" passed with a grade of ")  
    10. 
  
  
  
  10. .append(student1.getGrade().toString());  
    11. 
  
  
  
  11. break;  
    12. 
  
  
  
  12. case D: // fall through to F  
    13. 
  
  
  
  13. case F:  
    14. 
  
  
  
  14. outputText.append(" failed with a grade of ")  
    15. 
  
  
  
  15. .append(student1.getGrade().toString());  
    16. 
  
  
  
  16. break;  
    17. 
  
  
  
  17. case INCOMPLETE:  
    18. 
  
  
  
  18. outputText.append(" did not complete the class.");  
    19. 
  
  
  
  19. break;  
    20. 
  
  
  
  20. }  
    21. 
  
  
  
  21. out.println(outputText.toString());  
    22. 
  
  
  
  22. } 
    23.

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

现在，您应该已经了解使用 switch 语句时的基本语法，但是还有一些事情您需要知道。在使用 switch 之前进行计划
正如您所期待的，在使用枚举和 switch 时，您可以使用 default 语句。清单 7 显示了这个用法:

清单 7. 添加一个 default 块

 
 
 
    
  
  
  
  1. public void testSwitchStatement(PrintStream out) throws IOException {  
    2. 
  
  
  
  2. StringBuffer outputText = new StringBuffer(student1.getFullName());  
    3. 
  
  
  
  3. switch (student1.getGrade()) {  
    4. 
  
  
  
  4. case A:  
    5. 
  
  
  
  5. outputText.append(" excelled with a grade of A");  
    6. 
  
  
  
  6. break;  
    7. 
  
  
  
  7. case B: // fall through to C  
    8. 
  
  
  
  8. case C:  
    9. 
  
  
  
  9. outputText.append(" passed with a grade of ")  
    10. 
  
  
  
  10. .append(student1.getGrade().toString());  
    11. 
  
  
  
  11. break;  
    12. 
  
  
  
  12. case D: // fall through to F  
    13. 
  
  
  
  13. case F:  
    14. 
  
  
  
  14. outputText.append(" failed with a grade of ")  
    15. 
  
  
  
  15. .append(student1.getGrade().toString());  
    16. 
  
  
  
  16. break;  
    17. 
  
  
  
  17. case INCOMPLETE:  
    18. 
  
  
  
  18. outputText.append(" did not complete the class.");  
    19. 
  
  
  
  19. break;  
    20. 
  
  
  
  20. default:  
    21. 
  
  
  
  21. outputText.append(" has a grade of ")  
    22. 
  
  
  
  22. .append(student1.getGrade().toString());  
    23. 
  
  
  
  23. break;  
    24. 
  
  
  
  24. }  
    25. 
  
  
  
  25. out.println(outputText.toString());  
    26. 
  
  
  
  26. } 
    27.

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

清单 8. 给 Grade 枚举添加一个值

 
 
 
    
  
  
  
  1. package com.oreilly.tiger.ch03;  
    2. 
  
  
  
  2. public enum Grade {  
    3. 
  
  
  
  3. A, B, C, D, F, INCOMPLETE,  
    4. 
  
  
  
  4. WITHDREW_PASSING, WITHDREW_FAILING  
    5. 
  
  
  
  5. }; 
    6.

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

枚举和集合

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

清单 9. Ant 状态码

 
 
 
    
  
  
  
  1. package com.oreilly.tiger.ch03;  
    2. 
  
  
  
  2. public enum AntStatus {  
    3. 
  
  
  
  3. INITIALIZING,  
    4. 
  
  
  
  4. COMPILING,  
    5. 
  
  
  
  5. COPYING,  
    6. 
  
  
  
  6. JARRING,  
    7. 
  
  
  
  7. ZIPPING,  
    8. 
  
  
  
  8. DONE,  
    9. 
  
  
  
  9. ERROR  
    10. 
  
  
  
  10. } 
    11.

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

清单 10. 枚举的映射（Map）

 
 
 
    
  
  
  
  1. public void testEnumMap(PrintStream out) throws IOException {  
    2. 
  
  
  
  2. // Create a map with the key and a String message  
    3. 
  
  
  
  3. EnumMap antMessages =  
    4. 
  
  
  
  4. new EnumMap(AntStatus.class);  
    5. 
  
  
  
  5. // Initialize the map  
    6. 
  
  
  
  6. antMessages.put(AntStatus.INITIALIZING, "Initializing Ant...");  
    7. 
  
  
  
  7. antMessages.put(AntStatus.COMPILING, "Compiling Java classes...");  
    8. 
  
  
  
  8. antMessages.put(AntStatus.COPYING, "Copying files...");  
    9. 
  
  
  
  9. antMessages.put(AntStatus.JARRING, "JARring up files...");  
    10. 
  
  
  
  10. antMessages.put(AntStatus.ZIPPING, "ZIPping up files...");  
    11. 
  
  
  
  11. antMessages.put(AntStatus.DONE, "Build complete.");  
    12. 
  
  
  
  12. antMessages.put(AntStatus.ERROR, "Error occurred.");  
    13. 
  
  
  
  13. // Iterate and print messages  
    14. 
  
  
  
  14. for (AntStatus status : AntStatus.values() ) {  
    15. 
  
  
  
  15. out.println("For status " + status + ", message is: " +  
    16. 
  
  
  
  16. antMessages.get(status));  
    17. 
  
  
  
  17. }  
    18. 
  
  
  
  18. } 
    19.

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

枚举的 Class 对象

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

清单 11. 清单 10 的输出

 
 
 
    
  
  
  
  1. [echo] Running AntStatusTester...  
    2. 
  
  
  
  2. [java] For status INITIALIZING, message is: Initializing Ant...  
    3. 
  
  
  
  3. [java] For status COMPILING, message is: Compiling Java classes...  
    4. 
  
  
  
  4. [java] For status COPYING, message is: Copying files...  
    5. 
  
  
  
  5. [java] For status JARRING, message is: JARring up files...  
    6. 
  
  
  
  6. [java] For status ZIPPING, message is: ZIPping up files...  
    7. 
  
  
  
  7. [java] For status DONE, message is: Build complete.  
    8. 
  
  
  
  8. [java] For status ERROR, message is: Error occurred. 
    9.

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

使用枚举，但是不要滥用

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

名称栏目：java枚举类型入门
URL分享：http://www.mswzjz.com/qtweb/news10/167960.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

商城网站知识

各行业网站

成都印刷厂　　 　LED显示屏　　 　百度推广公司　　 　重庆机房托管　　 　四川航空文化　　 　乐山服务器托管　　 　内江做网站　　 　成都logo设计标志　　 　高端网站设计　　 　三台网站建设　　 　西部信息服务器托管　　 　复盛机电设备安装　　 　虚拟主机　　 　卡多尼人工智　　 　四川和正源　　 　成都网站推广营销　　 　品牌网站建设　　 　营销型网站建设　　 　微信公众号开发　　 　成都谷歌SEO