java枚举怎么用的

时间  2021-02-17
标签 java 安全 ide this url spa .net code 视频 对象 栏目 Java 繁體版
原文   原文链接


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

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


安全

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

ide

String code;
String desc;

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





this

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


url

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


spa

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


.net

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



code

 

 

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中须要表示诸如颜色、方式、类别、状态等等数目有限、形式离散、表达又极为明确的量，应当尽可能舍弃常量表示的作法，而将枚举做为首要的选择。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程