java枚举怎么用的


package com.pingan.property.icore.pap.common.constants;

/**
*
*/
public enum UMAuthStatusEnum implements BaseEnumI {

// UM验证失败的几种原因
AUTHORIZATION_IS_NULL("0", "header auth信息为空"),
UM_API_FAILED("1", "um系统API调用失败");

String code;
String desc;

private UMAuthStatusEnum(String code, String desc) {
this.code = code;
this.desc = desc;
}

@Override
public void setCode(String code) {
this.code = code;
}

@Override
public String getCode() {
return this.code;
}

@Override
public void setDesc(String desc) {
this.desc = desc;
}

@Override
public String getDesc() {
return this.desc;
}
}

Java 枚举7常见种用法

用法一：常量

在JDK1.5 之前，我们定义常量都是： publicstaticfianl.... 。现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。

Java代码 
  1. public enum Color {  
  2.   RED, GREEN, BLANK, YELLOW  
  3. }  

用法二：switch

JDK1.6之前的switch语句只支持int,char,enum类型，使用枚举，能让我们的代码可读性更强。

Java代码 
  1. enum Signal {  
  2.     GREEN, YELLOW, RED  
  3. }  
  4. public class TrafficLight {  
  5.     Signal color = Signal.RED;  
  6.     public void change() {  
  7.         switch (color) {  
  8.         case RED:  
  9.             color = Signal.GREEN;  
  10.             break;  
  11.         case YELLOW:  
  12.             color = Signal.RED;  
  13.             break;  
  14.         case GREEN:  
  15.             color = Signal.YELLOW;  
  16.             break;  
  17.         }  
  18.     }  
  19. }  

用法三：向枚举中添加新方法

如果打算自定义自己的方法，那么必须在enum实例序列的最后添加一个分号。而且 Java 要求必须先定义 enum 实例。

Java代码 
  1. public enum Color {  
  2.     RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
  3.     // 成员变量  
  4.     private String name;  
  5.     private int index;  
  6.     // 构造方法  
  7.     private Color(String name, int index) {  
  8.         this.name = name;  
  9.         this.index = index;  
  10.     }  
  11.     // 普通方法  
  12.     public static String getName(int index) {  
  13.         for (Color c : Color.values()) {  
  14.             if (c.getIndex() == index) {  
  15.                 return c.name;  
  16.             }  
  17.         }  
  18.         return null;  
  19.     }  
  20.     // get set 方法  
  21.     public String getName() {  
  22.         return name;  
  23.     }  
  24.     public void setName(String name) {  
  25.         this.name = name;  
  26.     }  
  27.     public int getIndex() {  
  28.         return index;  
  29.     }  
  30.     public void setIndex(int index) {  
  31.         this.index = index;  
  32.     }  
  33. }  

用法四：覆盖枚举的方法

下面给出一个toString()方法覆盖的例子。

Java代码 
  1. public enum Color {  
  2.     RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
  3.     // 成员变量  
  4.     private String name;  
  5.     private int index;  
  6.     // 构造方法  
  7.     private Color(String name, int index) {  
  8.         this.name = name;  
  9.         this.index = index;  
  10.     }  
  11.     //覆盖方法  
  12.     @Override  
  13.     public String toString() {  
  14.         return this.index+"_"+this.name;  
  15.     }  
  16. }  

用法五：实现接口

所有的枚举都继承自java.lang.Enum类。由于Java 不支持多继承，所以枚举对象不能再继承其他类。

Java代码 
  1. public interface Behaviour {  
  2.     void print();  
  3.     String getInfo();  
  4. }  
  5. public enum Color implements Behaviour{  
  6.     RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
  7.     // 成员变量  
  8.     private String name;  
  9.     private int index;  
  10.     // 构造方法  
  11.     private Color(String name, int index) {  
  12.         this.name = name;  
  13.         this.index = index;  
  14.     }  
  15. //接口方法  
  16.     @Override  
  17.     public String getInfo() {  
  18.         return this.name;  
  19.     }  
  20.     //接口方法  
  21.     @Override  
  22.     public void print() {  
  23.         System.out.println(this.index+":"+this.name);  
  24.     }  
  25. }  

用法六：使用接口组织枚举

Java代码 
  1. public interface Food {  
  2.     enum Coffee implements Food{  
  3.         BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO  
  4.     }  
  5.     enum Dessert implements Food{  
  6.         FRUIT, CAKE, GELATO  
  7.     }  
  8. }  

用法七：关于枚举集合的使用

java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复；EnumMap中的 key是enum类型，而value则可以是任意类型。关于这个两个集合的使用就不在这里赘述，可以参考JDK文档。

关于枚举的实现细节和原理请参考：

参考资料：《ThinkingInJava》第四版

下文转自http://blog.csdn.net/u014527058/article/details/52751488 感谢作者

枚举（enum），是指一个经过排序的、被打包成一个单一实体的项列表。一个枚举的实例可以使用枚举项列表中任意单一项的值。枚举在各个语言当中都有着广泛的应用，通常用来表示诸如颜色、方式、类别、状态等等数目有限、形式离散、表达又极为明确的量。Java从JDK5开始，引入了对枚举的支持。

在枚举出现之前，如果想要表示一组特定的离散值，往往使用一些常量。例如：

[java] view plain copy
 
  1. package com.fhp.enumexample;  
  2.   
  3. public class Entity {  
  4.       
  5.     public static final int VIDEO = 1;//视频  
  6.     public static final int AUDIO = 2;//音频  
  7.     public static final int TEXT = 3;//文字  
  8.     public static final int IMAGE = 4;//图片  
  9.       
  10.     private int id;  
  11.     private int type;  
  12.       
  13.     public int getId() {  
  14.         return id;  
  15.     }  
  16.     public void setId(int id) {  
  17.         this.id = id;  
  18.     }  
  19.     public int getType() {  
  20.         return type;  
  21.     }  
  22.     public void setType(int type) {  
  23.         this.type = type;  
  24.     }  
  25.       
  26.       
  27. }  

当然，常量也不仅仅局限于int型，诸如char和String等也是不在少数。然而，无论使用什么样的类型，这样做都有很多的坏处。这些常量通常都是连续、有无穷多个值的量，而类似这种表示类别的量则是离散的，并且通常情况下只有有限个值。用连续的量去表示离散量，会产生很多问题。例如，针对上述的Entity类，如果要对Entity对象的type属性进行赋值，一般会采用如下方法：

[java] view plain copy
 
  1. Entity e = new Entity();  
  2. e.setId(10);  
  3. e.setType(2);  

这样做的缺点有：（1）代码可读性差、易用性低。由于setType()方法的参数是int型的，在阅读代码的时候往往会让读者感到一头雾水，根本不明白这个2到底是什么意思，代表的是什么类型。当然，要保证可读性，还有这样一个办法：

[java] view plain copy
 
  1. e.setType(Entity.AUDIO);  


而这样的话，问题又来了。这样做，客户端必须对这些常量去建立理解，才能了解如何去使用这个东西。说白了，在调用的时候，如果用户不到Entity类中去看看，还真不知道这个参数应该怎么传、怎么调。像是setType(2)这种用法也是在所难免，因为它完全合法，不是每个人都能够建立起用常量名代替数值，从而增加程序可读性、降低耦合性的意识。

（2）类型不安全。在用户去调用的时候，必须保证类型完全一致，同时取值范围也要正确。像是setType(-1)这样的调用是合法的，但它并不合理，今后会为程序带来种种问题。也许你会说，加一个有效性验证嘛，但是，这样做的话，又会引出下面的第(3)个问题。

（3）耦合性高，扩展性差。假如，因为某些原因，需要修改Entity类中常量的值，那么，所有用到这些常量的代码也就都需要修改——当然，要仔细地修改，万一漏了一个，那可不是开玩笑的。同时，这样做也不利于扩展。例如，假如针对类别做了一个有效性验证，如果类别增加了或者有所变动，则有效性验证也需要做对应的修改，不利于后期维护。


枚举就是为了这样的问题而诞生的。它们给出了将一个任意项同另一个项相比较的能力，并且可以在一个已定义项列表中进行迭代。枚举（在Jave中简称为enum）是一个特定类型的类。所有枚举都是Java中的新类java.lang.Enum的隐式子类。此类不能手工进行子类定义。一个简单的枚举可以是这样：

[java] view plain copy
 
  1. package com.fhp.enumexample;  
  2.   
  3. public enum TypeEnum {  
  4.     VIDEO, AUDIO, TEXT, IMAGE  
  5. }  

上面的Entity类就可以改成这样：

[java] view plain copy
 
  1. package com.fhp.enumexample;  
  2.   
  3. public class Entity {  
  4.       
  5.     private int id;  
  6.     private TypeEnum type;  
  7.       
  8.     public int getId() {  
  9.         return id;  
  10.     }  
  11.     public void setId(int id) {  
  12.         this.id = id;  
  13.     }  
  14.           
  15.     public TypeEnum getType() {  
  16.         return type;  
  17.     }  
  18.     public void setType(TypeEnum type) {  
  19.         this.type = type;  
  20.     }  
  21. }  


在为Entity对象赋值的时候，就可以这样：

[java] view plain copy
 
  1. Entity e = new Entity();  
  2. e.setId(10);  
  3. e.setType(TypeEnum.AUDIO);  


怎么看，都是好了很多。在调用setType()时，可选值只有四个，否则会出现编译错误，因此可以看出，枚举是类型安全的，不会出现取值范围错误的问题。同时，客户端不需要建立对枚举中常量值的了解，使用起来很方便，并且可以容易地对枚举进行修改，而无需修改客户端。如果常量从枚举中被删除了，那么客户端将会失败并且将会收到一个错误消息。枚举中的常量名称可以被打印，因此除了仅仅得到列表中项的序号外还可以获取更多信息。这也意味着常量可用作集合的名称，例如HashMap。



因为在Java中一个枚举就是一个类，它也可以有属性和方法，并且实现接口。只是所有的枚举都继承自java.lang.Enum类，因此enum不可以再继承其他的类。

下面给出在枚举中声明属性和方法的示例：

[java] view plain copy
 
  1. package com.fhp.enumexample;  
  2.   
  3. public enum TypeEnum {  
  4.     VIDEO(1), AUDIO(2), TEXT(3), IMAGE(4);  
  5.       
  6.     int value;  
  7.       
  8.     TypeEnum(int value) {  
  9.         this.value = value;  
  10.     }  
  11.       
  12.     public int getValue() {  
  13.         return value;  
  14.     }  
  15. }  


在这个枚举中，每个枚举的值都有一个对应的int型字段，而且不同的枚举值也会有不同的int数值。同时，它和普通的类一样，可以声明构造器和各种各样的方法。如：

[java] view plain copy
 
  1. TypeEnum type = TypeEnum.TEXT;//type的value属性值为3。  
  2. System.out.println(type.getValue());//屏幕输出3。  

如果要为每个枚举值指定属性，则在枚举中必须声明一个参数为属性对应类型的构造方法（不能是public）。否则编译器将给出The constructor TypeEnum(int, String) is undefined的错误。在此例中，属性为int型，因此构造方法应当为int型。除此之外，还可以为枚举指定多个属性，如：

[java] view plain copy
 
  1. package com.fhp.enumexample;  
  2.   
  3. public enum TypeEnum {  
  4.     VIDEO(1, "视频"), AUDIO(2, "音频"), TEXT(3, "文本"), IMAGE(4, "图像");  
  5.       
  6.     int value;  
  7.     String name;  
  8.       
  9.     TypeEnum(int value, String name) {  
  10.         this.value = value;  
  11.         this.name = name;  
  12.     }  
  13.       
  14.     public int getValue() {  
  15.         return value;  
  16.     }  
  17.       
  18.     public String getName() {  
  19.         return name;  
  20.     }  
  21. }  


enum还内置了许多方法，常用的如下：

int compareTo(E o) 
          比较此枚举与指定对象的顺序。


Class<E> getDeclaringClass() 
          返回与此枚举常量的枚举类型相对应的 Class 对象。


String name() 
          返回此枚举常量的名称，在其枚举声明中对其进行声明。


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


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


static <T extends Enum<T>> T valueOf(Class<T> enumType, String name) 
          返回带指定名称的指定枚举类型的枚举常量。


static T[] values()

返回该枚举的所有值。

现在，假设要为该枚举实现一个根据整数值生成枚举值的方法，可以这样做：

[java] view plain copy
 
  1. package com.fhp.enumexample;  
  2.   
  3. public enum TypeEnum {  
  4.     VIDEO(1, "视频"), AUDIO(2, "音频"), TEXT(3, "文本"), IMAGE(4, "图像");  
  5.       
  6.     int value;  
  7.     String name;  
  8.       
  9.     TypeEnum(int value, String name) {  
  10.         this.value = value;  
  11.         this.name = name;  
  12.     }  
  13.       
  14.     public int getValue() {  
  15.         return value;  
  16.     }  
  17.       
  18.     public String getName() {  
  19.         return name;  
  20.     }  
  21.   
  22.     public TypeEnum getByValue(int value) {  
  23.         for(TypeEnum typeEnum : TypeEnum.values()) {  
  24.             if(typeEnum.value == value) {  
  25.                 return typeEnum;  
  26.             }  
  27.         }  
  28.         throw new IllegalArgumentException("No element matches " + value);  
  29.     }  
  30. }  


getByValue(int)即为整数值转枚举值的方法。调用values()方法获取到该枚举下的所有值，然后遍历该枚举下面的每个值和给定的整数是否匹配，若匹配直接返回，若无匹配值则抛出IllegalArgumentException异常，表示参数不合法，兼有有效性验证的作用。

综上，我们可以看到，在JDK5中新引入的枚举完美地解决了之前通过常量来表示离散量所带来的问题，大大加强了程序的可读性、易用性和可维护性，并且在此基础之上又进行了扩展，使之可以像类一样去使用，更是为Java对离散量的表示上升了一个台阶。因此，如果在Java中需要表示诸如颜色、方式、类别、状态等等数目有限、形式离散、表达又极为明确的量，应当尽量舍弃常量表示的做法，而将枚举作为首要的选择。

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/panxuejun/p/7246283.html