码迷，mamicode.com
首页 > 编程语言 > 详细

JAVA 枚举

时间：2015-01-23 17:51:31      阅读：191      评论：0      收藏：0      [点我收藏+]

标签：

 

掌握java枚举类型(enum type)

1 背景

 在java语言中还没有引入枚举类型之前，表示枚举类型的常用模式是声明一组具有int常量。之前我们通常利用public final static 方法定义的代码如下，分别用1 表示春天，2表示夏天，3表示秋天，4表示冬天。

Java代码  
  1. public class Season {  
  2.     public static final int SPRING = 1;  
  3.     public static final int SUMMER = 2;  
  4.     public static final int AUTUMN = 3;  
  5.     public static final int WINTER = 4;  
  6. }  

  

这种方法称作int枚举模式。可这种模式有什么问题呢，我们都用了那么久了，应该没问题的。通常我们写出来的代码都会考虑它的安全性、易用性和可读性。

首先我们来考虑一下它的类型安全性。当然这种模式不是类型安全的。比如说我们设计一个函数，要求传入春夏秋冬的某个值。但是使用int类型，我们无法保证传入的值为合法。代码如下所示：

Java代码  
  1. public class Season {  
  2.     public static final int SPRING = 1;  
  3.     public static final int SUMMER = 2;  
  4.     public static final int AUTUMN = 3;  
  5.     public static final int WINTER = 4;  
  6.       
  7.     private String getChineseSeason(int season){  
  8.         StringBuffer result = new StringBuffer();  
  9.         switch(season){  
  10.             case Season.SPRING :  
  11.                 result.append("春天");  
  12.                 break;  
  13.             case Season.SUMMER :  
  14.                 result.append("夏天");  
  15.                 break;  
  16.             case Season.AUTUMN :  
  17.                 result.append("秋天");  
  18.                 break;  
  19.             case Season.WINTER :  
  20.                 result.append("冬天");  
  21.                 break;  
  22.             default :  
  23.                 result.append("地球没有的季节");  
  24.                 break;  
  25.         }  
  26.         return result.toString();  
  27.     }  
  28.       
  29.     public void doSomething(){  
  30.         System.out.println(this.getChineseSeason(Season.SPRING));//这是正常的场景  
  31.           
  32.         System.out.println(this.getChineseSeason(5));//这个却是不正常的场景，这就导致了类型不安全问题  
  33.     }  
  34.       
  35.     public static void main(String[] arg){  
  36.         Season season = new Season();  
  37.         season.doSomething();  
  38.     }  
  39. }  

  

程序getChineseSeason(Season.SPRING)是我们预期的使用方法。可getChineseSeason(5)显然就不是了，而且编译很通过，在运行时会出现什么情况，我们就不得而知了。这显然就不符合Java程序的类型安全。

接下来我们来考虑一下这种模式的可读性。使用枚举的大多数场合，我都需要方便得到枚举类型的字符串表达式。如果将int枚举常量打印出来，我们所见到的就是一组数字，这是没什么太大的用处。我们可能会想到使用String常量代替int常量。虽然它为这些常量提供了可打印的字符串，但是它会导致性能问题，因为它依赖于字符串的比较操作，所以这种模式也是我们不期望的。

从类型安全性和程序可读性两方面考虑，int和String枚举模式的缺点就显露出来了。幸运的是，从Java1.5发行版本开始，就提出了另一种可以替代的解决方案，可以避免int和String枚举模式的缺点，并提供了许多额外的好处。那就是枚举类型（enum type）。接下来的章节将介绍枚举类型的定义、特征、应用场景和优缺点。

2 定义

枚举类型（enum type）是指由一组固定的常量组成合法的类型。Java中由关键字enum来定义一个枚举类型。下面就是java枚举类型的定义。

Java代码  
  1. public enum Season {  
  2.     SPRING, SUMMER, AUTUMN, WINTER;  
  3. }  

  

3 特点

Java定义枚举类型的语句很简约。它有以下特点：

1)  使用关键字enum

2)  类型名称，比如这里的Season

3)  一串允许的值，比如上面定义的春夏秋冬四季

4)  枚举可以单独定义在一个文件中，也可以嵌在其它Java类中

除了这样的基本要求外，用户还有一些其他选择

5)  枚举可以实现一个或多个接口（Interface）

6)  可以定义新的变量

7)  可以定义新的方法

8)  可以定义根据具体枚举值而相异的类

4 代码展示

以在背景中提到的类型安全为例，用枚举类型重写那段代码。代码如下：

 

Java代码  
  1. public enum Season {  
  2.     SPRING(1), SUMMER(2), AUTUMN(3), WINTER(4);  
  3.       
  4.     private int code;  
  5.     private Season(int code){  
  6.         this.code = code;  
  7.     }  
  8.       
  9.     public int getCode(){  
  10.         return code;  
  11.     }  
  12. }  
Java代码  
  1. public class UseSeason {  
  2.     /** 
  3.      * 将英文的季节转换成中文季节 
  4.      * @param season 
  5.      * @return 
  6.      */  
  7.     private String getChineseSeason(Season season){  
  8.         String result = "";  
  9.         switch(season){  
  10.             case SPRING :  
  11.                 result = appendSeason("春天", season);  
  12.                 break;  
  13.             case AUTUMN :  
  14.                 result = appendSeason("秋天", season);  
  15.                 break;  
  16.             case SUMMER :   
  17.                 result = appendSeason("夏天", season);  
  18.                 break;  
  19.             case WINTER :  
  20.                 result = appendSeason("冬天", season);  
  21.                 break;  
  22.             default :  
  23.                 result = appendSeason("地球没有的季节", season);  
  24.                 break;  
  25.         }  
  26.         return result.toString();  
  27.     }  
  28.       
  29.     private String appendSeason(String chineseName, Season season){  
  30.         StringBuffer result = new StringBuffer();  
  31.         result.append("[中文：" + chineseName + "，枚举常量:" + season.name() + "，数据:" + season.getCode() + "]");  
  32.         return result.toString();  
  33.     }  
  34.       
  35.     public void doSomething(){  
  36.         for(Season s : Season.values()){  
  37.             System.out.println(getChineseSeason(s));//这是正常的场景  
  38.         }  
  39.         //System.out.println(getChineseSeason(5));  
  40.         //此处已经是编译不通过了，这就保证了类型安全  
  41.     }  
  42.       
  43.     public static void main(String[] arg){  
  44.         UseSeason useSeason = new UseSeason();  
  45.         useSeason.doSomething();  
  46.     }  
  47. }  
Java代码  
  1. [中文：春天，枚举常量:SPRING，数据:1]  
  2. [中文：夏天，枚举常量:SUMMER，数据:2]  
  3. [中文：秋天，枚举常量:AUTUMN，数据:3]  
  4. [中文：冬天，枚举常量:WINTER，数据:4]  

这里有一个问题，为什么我要将域添加到枚举类型中呢？目的是想将数据与它的常量关联起来。如1代表春天，2代表夏天。

5 总结

那么什么时候应该使用枚举呢？每当需要一组固定的常量的时候，如一周的天数、一年四季等。或者是在我们编译前就知道其包含的所有值的集合。优点是：枚举能满足绝大部分程序员的要求的，它的简明，易用的特点是很突出的。缺点：与int常量相比，枚举有个小小的性能缺点，即装载和初始化枚举时会有空间和时间的成本。如受资源约束的设备：手机等。但是在实践中不必太在意这个问题。

此博客为原创，转载请保留此出处，谢谢。

JAVA 枚举

标签：

原文地址：http://www.cnblogs.com/leonkobe/p/4244678.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！