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教程