本文目錄一覽：
enum在java中是什麼意思
Enum 類型的介紹
枚舉類型（Enumerated Type） 很早就出現在編程語言中，它被用來將一組類似的值包含到一種類型當中。而這種枚舉類型的名稱則會被定義成獨一無二的類型描述符，在這一點上和常量的定義相似。不過相比較常量類型，枚舉類型可以為申明的變量提供更大的取值範圍。
舉個例子來說明一下，如果希望為彩虹描繪出七種顏色，你可以在 Java 程序中通過常量定義方式來實現。
清單 1. 常量定義
Public static class RainbowColor {
// 紅橙黃綠青藍紫七種顏色的常量定義
public static final int RED = 0;
public static final int ORANGE = 1;
public static final int YELLOW = 2;
public static final int GREEN = 3;
public static final int CYAN = 4;
public static final int BLUE = 5;
public static final int PURPLE = 6;
}
使用的時候，你可以在程序中直接引用這些常量。但是，這種方式還是存在着一些問題。
類型不安全
由於顏色常量的對應值是整數形，所以程序執行過程中很有可能給顏色變量傳入一個任意的整數值，導致出現錯誤。
沒有命名空間
由於顏色常量只是類的屬性，當你使用的時候不得不通過類來訪問。
一致性差
因為整形枚舉屬於編譯期常量，所以編譯過程完成後，所有客戶端和服務器端引用的地方，會直接將整數值寫入。這樣，當你修改舊的枚舉整數值後或者增加新的枚舉值後，所有引用地方代碼都需要重新編譯，否則運行時刻就會出現錯誤。
類型無指意性
由於顏色枚舉值僅僅是一些無任何含義的整數值，如果在運行期調試時候，你就會發現日誌中有很多魔術數字，但除了程序員本身，其他人很難明白其奧秘。
如何定義 Enum 類型
為了改進 Java 語言在這方面的不足彌補缺陷，5.0 版本 SDK 發布時候，在語言層面上增加了枚舉類型。枚舉類型的定義也非常的簡單，用 enum 關鍵字加上名稱和大括號包含起來的枚舉值體即可，例如上面提到的彩虹顏色就可以用新的 enum 方式來重新定義：
enum RainbowColor { RED, ORANGE, YELLOW, GREEN, CYAN, BLUE, PURPLE }
從上面的定義形式來看，似乎 Java 中的枚舉類型很簡單，但實際上 Java 語言規範賦予枚舉類型的功能非常的強大，它不僅是簡單地將整形數值轉換成對象，而是將枚舉類型定義轉變成一個完整功能的類定義。這種類型定義的擴展允許開發者給枚舉類型增加任何方法和屬性，也可以實現任意的接口。另外，Java 平台也為 Enum 類型提供了高質量的實現，比如默認實現 Comparable 和 Serializable 接口，讓開發者一般情況下不用關心這些細節。
回到本文的主題上來，引入枚舉類型到底能夠給我們開發帶來什麼樣好處呢？一個最直接的益處就是擴大 switch 語句使用範圍。5.0 之前，Java 中 switch 的值只能夠是簡單類型，比如 int、byte、short、char, 有了枚舉類型之後，就可以使用對象了。這樣一來，程序的控制選擇就變得更加的方便，看下面的例子：
清單 2. 定義 Enum 類型
// 定義一周七天的枚舉類型
public enum WeekDayEnum { Mon, Tue, Wed, Thu, Fri, Sat, Sun }
// 讀取當天的信息
WeekDayEnum today = readToday();
// 根據日期來選擇進行活動
switch(today) {
Mon: do something; break;
Tue: do something; break;
Wed: do something; break;
Thu: do something; break;
Fri: do something; break;
Sat: play sports game; break;
Sun: have a rest; break;
}
對於這些枚舉的日期，JVM 都會在運行期構造成出一個簡單的對象實例一一對應。這些對象都有唯一的 identity，類似整形數值一樣，switch 語句就根據此來進行執行跳轉。
如何定製 Enum 類型
除了以上這種最常見的枚舉定義形式外，如果需要給枚舉類型增加一些複雜功能，也可以通過類似 class 的定義來給枚舉進行定製。比如要給 enum 類型增加屬性，可以像下面這樣定義：
清單 3. 定製枚舉類型
// 定義 RSS(Really Simple Syndication) 種子的枚舉類型
public enum NewsRSSFeedEnum {
// 雅虎頭條新聞 RSS 種子
YAHOO_TOP_STORIES(“”),
//CBS 頭條新聞 RSS 種子
CBS_TOP_STORIES(“”),
// 洛杉磯時報頭條新聞 RSS 種子
LATIMES_TOP_STORIES(“”);
// 枚舉對象的 RSS 地址的屬性
private String rss_url;
// 枚舉對象構造函數
private NewsRSSFeedEnum(String rss) {
this.rss_url = rss;
}
// 枚舉對象獲取 RSS 地址的方法
public String getRssURL() {
return this.rss_url;
}
}
上面頭條新聞的枚舉類型增加了一個 RSS 地址的屬性 , 記錄頭條新聞的訪問地址。同時，需要外部傳入 RSS 訪問地址的值，因而需要定義一個構造函數來初始化此屬性。另外，還需要向外提供方法來讀取 RSS 地址。
如何避免錯誤使用 Enum
不過在使用 Enum 時候有幾個地方需要注意：
enum 類型不支持 public 和 protected 修飾符的構造方法，因此構造函數一定要是 private 或 friendly 的。也正因為如此，所以枚舉對象是無法在程序中通過直接調用其構造方法來初始化的。
定義 enum 類型時候，如果是簡單類型，那麼最後一個枚舉值後不用跟任何一個符號；但如果有定製方法，那麼最後一個枚舉值與後面代碼要用分號’;’隔開，不能用逗號或空格。
由於 enum 類型的值實際上是通過運行期構造出對象來表示的，所以在 cluster 環境下，每個虛擬機都會構造出一個同義的枚舉對象。因而在做比較操作時候就需要注意，如果直接通過使用等號 ( ‘ == ’ ) 操作符，這些看似一樣的枚舉值一定不相等，因為這不是同一個對象實例。
看下面的這個例子：
清單 4. 避免錯誤使用 Enum 示例
// 定義一個一周七天的枚舉類型
package example.enumeration.codes;
public enum WeekDayEnum {
Mon(1), Tue(2), Wed(3), Thu(4), Fri(5), Sat(6), Sun(7);
private int index;
WeekDayEnum(int idx) {
this.index = idx;
}
public int getIndex() {
return index;
}
}
// 客戶端程序，將一個枚舉值通過網絡傳遞給服務器端
package example.enumeration.codes;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.UnknownHostException;
public class EnumerationClient {
public static void main(String… args) throws UnknownHostException, IOException {
Socket socket = new Socket();
// 建立到服務器端的連接
socket.connect(new InetSocketAddress(“127.0.0.1”, 8999));
// 從連接中得到輸出流
OutputStream os = socket.getOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(os);
// 將星期五這個枚舉值傳遞給服務器端
oos.writeObject(WeekDayEnum.Fri);
oos.close();
os.close();
socket.close();
}
}
// 服務器端程序，將從客戶端收到的枚舉值應用到邏輯處理中
package example.enumeration.codes;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class EnumerationServer {
public static void main(String… args) throws IOException, ClassNotFoundException {
ServerSocket server = new ServerSocket(8999);
// 建立服務器端的網絡連接偵聽
Socket socket = server.accept();
// 從連接中獲取輸入流
InputStream is = socket.getInputStream();
ObjectInputStream ois = new ObjectInputStream(is);
// 讀出客戶端傳遞來的枚舉值
WeekDayEnum day = (WeekDayEnum) ois.readObject();
// 用值比較方式來對比枚舉對象
if (day == WeekDayEnum.Fri) {
System.out.println(“client Friday enum value is same as server’s”);
} else if (day.equals(WeekDayEnum.Fri)) {
System.out.println(“client Friday enum value is equal to server’s”);
} else {
System.out.println(“client Friday enum value is not same as server’s”);
}
// 用 switch 方式來比較枚舉對象
switch (day) {
case Mon:
System.out.println(“Do Monday work”);
break;
case Tue:
System.out.println(“Do Tuesday work”);
break;
case Wed:
System.out.println(“Do Wednesday work”);
break;
case Thu:
System.out.println(“Do Thursday work”);
break;
case Fri:
System.out.println(“Do Friday work”);
break;
case Sat:
System.out.println(“Do Saturday work”);
break;
case Sun:
System.out.println(“Do Sunday work”);
break;
default:
System.out.println(“I don’t know which is day”);
break;
}
ois.close();
is.close();
socket.close();
}
}
打印結果如下：
client Friday enum value is same as server’s
Do Friday work
通過程序執行結果，我們能夠發現在分布式條件下客戶端和服務端的虛擬機上都生成了一個枚舉對象，即使看起來一樣的 Fri 枚舉值，如果使用等號‘ == ’進行比較的話會出現不等的情況。而 switch 語句則是通過 equal 方法來比較枚舉對象的值，因此當你的枚舉對象較複雜時候，你就需要小心 override 與比較相關的方法，防止出現值比較方面的錯誤。
Enum 相關工具類
JDK5.0 中在增加 Enum 類的同時，也增加了兩個工具類 EnumSet 和 EnumMap，這兩個類都放在 java.util 包中。EnumSet 是一個針對枚舉類型的高性能的 Set 接口實現。EnumSet 中裝入的所有枚舉對象都必須是同一種類型，在其內部，是通過 bit-vector 來實現，也就是通過一個 long 型數。EnumSet 支持在枚舉類型的所有值的某個範圍中進行迭代。回到上面日期枚舉的例子上：
enum WeekDayEnum { Mon, Tue, Wed, Thu, Fri, Sat, Sun }
你能夠在每周七天日期中進行迭代，EnumSet 類提供一個靜態方法 range 讓迭代很容易完成：
for(WeekDayEnum day : EnumSet.range(WeekDayEnum.Mon, WeekDayEnum.Fri)) {
System.out.println(day);
}
打印結果如下：
Mon
Tue
Wed
Thu
Fri
EnumSet 還提供了很多個類型安全的獲取子集的 of 方法，使你很容易取得子集：
EnumSetWeekDayEnum subset = EnumSet.of(WeekDayEnum.Mon, WeekDayEnum.Wed);
for (WeekDayEnum day : subset) {
System.out.println(day);
}
打印結果如下：
Mon
Wed
與 EnumSet 類似，EnumMap 也是一個高性能的 Map 接口實現，用來管理使用枚舉類型作為 keys 的映射表，內部是通過數組方式來實現。EnumMap 將豐富的和安全的 Map 接口與數組快速訪問結合到一起，如果你希望要將一個枚舉類型映射到一個值，你應該使用 EnumMap。看下面的例子：
清單 5. EnumMap 示例
// 定義一個 EnumMap 對象，映射表主鍵是日期枚舉類型，值是顏色枚舉類型
private static MapWeekDayEnum, RainbowColor schema =
new EnumMapWeekDayEnum, RainbowColor(WeekDayEnum.class);
static{
// 將一周的每一天與彩虹的某一種色彩映射起來
for (int i = 0; i WeekDayEnum.values().length; i++) {
schema.put(WeekDayEnum.values()[i], RainbowColor.values()[i]);
}
}
System.out.println(“What is the lucky color today?”);
System.out.println(“It’s ” + schema.get(WeekDayEnum.Sat));
當你詢問周六的幸運色彩時候，會得到藍色：
清單 6. 運行結果
What is the lucky color today?
It’s BLUE
結束語
Enum 類型提出給 JAVA 編程帶了了極大的便利，讓程序的控制更加的容易，也不容易出現錯誤。所以在遇到需要控制程序流程時候，可以多想想是否可以利用 enum 來實現。
java枚舉類型
java 枚舉類型enum 的使用
最近跟同事討論問題的時候，突然同事提到我們為什麼java 中定義的常量值不採用enmu 枚舉類型，而採用public final static 類型來定義呢？以前我們都是採用這種方式定義的，很少採用enum 定義，所以也都沒有注意過，面對突入起來的問題，還真有點不太清楚為什麼有這樣的定義。既然不明白就抽時間研究下吧。
Java 中的枚舉類型採用關鍵字enum 來定義，從jdk1.5才有的新類型，所有的枚舉類型都是繼承自Enum 類型。要了解枚舉類型，建議大家先打開jdk 中的Enum類簡單讀一下，這個類裡面定義了很多protected 方法，比如構造函數，如果要使用這些方法我們可以把枚舉類型定義到當前類中。每個枚舉類型，都有自己的名字和順序，當我們輸出一個枚舉類型的時候，會輸入枚舉類型的name ，具體可以參考下面的例子。
一、 通常定義常量方法
我們通常利用public final static 方法定義的代碼如下，分別用1 表示紅燈，3 表示綠燈，2 表示黃燈。
package com.csdn.myEnum;
public class Light {
/* 紅燈 */
public final static int RED =1;
/* 綠燈 */
public final static int GREEN =3;
/* 黃燈 */
public final static int YELLOW =2;
}
二、 枚舉類型定義常量方法
枚舉類型的簡單定義方法如下，我們似乎沒辦法定義每個枚舉類型的值。比如我們定義紅燈、綠燈和黃燈的代碼可能如下：
public enum Light {
RED , GREEN , YELLOW ;
}
我們只能夠表示出紅燈、綠燈和黃燈，但是具體的值我們沒辦法表示出來。別急，既然枚舉類型提供了構造函數，我們可以通過構造函數和覆寫toString方法來實現。首先給Light 枚舉類型增加構造方法，然後每個枚舉類型的值通過構造函數傳入對應的參數，同時覆寫toString 方法，在該方法中返回從構造函數中傳入的參數，改造後的代碼如下：
public enum Light {
// 利用構造函數傳參
RED (1), GREEN (3), YELLOW (2);
// 定義私有變量
private int nCode ;
// 構造函數，枚舉類型只能為私有
private Light( int _nCode) {
this . nCode = _nCode;
}
@Override
public String toString() {
return String.valueOf ( this . nCode );
}
}
三、 完整示例代碼
枚舉類型的完整演示代碼如下：
package com.csdn.myEnum;
import java.util.EnumMap;
import java.util.EnumSet;
public class LightTest {
// 1. 定義枚舉類型
public enum Light {
// 利用構造函數傳參
RED (1), GREEN (3), YELLOW (2);
// 定義私有變量
private int nCode ;
// 構造函數，枚舉類型只能為私有
private Light( int _nCode) {
this . nCode = _nCode;
}
@Override
public String toString() {
return String.valueOf ( this . nCode );
}
}
/**
* @param args
*/
public static void main(String[] args ) {
// 1. 遍歷枚舉類型
System. out .println( ” 演示枚舉類型的遍歷 ……” );
testTraversalEnum ();
// 2. 演示 EnumMap 對象的使用
System. out .println( ” 演示 EnmuMap 對象的使用和遍歷 …..” );
testEnumMap ();
// 3. 演示 EnmuSet 的使用
System. out .println( ” 演示 EnmuSet 對象的使用和遍歷 …..” );
testEnumSet ();
}
/**
* 演示枚舉類型的遍歷
*/
private static void testTraversalEnum() {
Light[] allLight = Light.values ();
for (Light aLight : allLight) {
System. out .println( ” 當前燈 name ： ” + aLight.name());
System. out .println( ” 當前燈 ordinal ： ” + aLight.ordinal());
System. out .println( ” 當前燈： ” + aLight);
}
}
/**
* 演示 EnumMap 的使用， EnumMap 跟 HashMap 的使用差不多，只不過 key 要是枚舉類型
*/
private static void testEnumMap() {
// 1. 演示定義 EnumMap 對象， EnumMap 對象的構造函數需要參數傳入 , 默認是key 的類的類型
EnumMapLight, String currEnumMap = new EnumMapLight, String(
Light. class );
currEnumMap.put(Light. RED , ” 紅燈 ” );
currEnumMap.put(Light. GREEN , ” 綠燈 ” );
currEnumMap.put(Light. YELLOW , ” 黃燈 ” );
// 2. 遍歷對象
for (Light aLight : Light.values ()) {
System. out .println( “[key=” + aLight.name() + “,value=”
+ currEnumMap.get(aLight) + “]” );
}
}
/**
* 演示 EnumSet 如何使用， EnumSet 是一個抽象類，獲取一個類型的枚舉類型內容BR/
* 可以使用 allOf 方法
*/
private static void testEnumSet() {
EnumSetLight currEnumSet = EnumSet.allOf (Light. class );
for (Light aLightSetElement : currEnumSet) {
System. out .println( ” 當前 EnumSet 中數據為： ” + aLightSetElement);
}
}
}
執行結果如下：
演示枚舉類型的遍歷 ……
當前燈 name ： RED
當前燈 ordinal ： 0
當前燈： 1
當前燈 name ： GREEN
當前燈 ordinal ： 1
當前燈： 3
當前燈 name ： YELLOW
當前燈 ordinal ： 2
當前燈： 2
演示 EnmuMap 對象的使用和遍歷 …..
[key=RED,value= 紅燈 ]
[key=GREEN,value= 綠燈 ]
[key=YELLOW,value= 黃燈 ]
演示 EnmuSet 對象的使用和遍歷 …..
當前 EnumSet 中數據為： 1
當前 EnumSet 中數據為： 3
當前 EnumSet 中數據為： 2
四、 通常定義常量方法和枚舉定義常量方法區別
以下內容可能有些無聊，但絕對值得一窺
1. 代碼：
public class State {
public static final int ON = 1;
public static final Int OFF= 0;
}
有什麼不好了，大家都這樣用了很長時間了，沒什麼問題啊。
首先，它不是類型安全的。你必須確保是int
其次，你還要確保它的範圍是0 和1
最後，很多時候你打印出來的時候，你只看到 1 和0 ，
但其沒有看到代碼的人並不知道你的企圖，拋棄你所有舊的public static final 常量
2. 可以創建一個enum 類，把它看做一個普通的類。除了它不能繼承其他類了。(java 是單繼承，它已經繼承了Enum),
可以添加其他方法，覆蓋它本身的方法
3. switch() 參數可以使用enum 了
4. values() 方法是編譯器插入到enum 定義中的static 方法，所以，當你將enum 實例向上轉型為父類Enum 是，values() 就不可訪問了。解決辦法：在Class中有一個getEnumConstants() 方法，所以即便Enum 接口中沒有values() 方法，我們仍然可以通過Class 對象取得所有的enum 實例
5. 無法從enum 繼承子類，如果需要擴展enum 中的元素，在一個接口的內部，創建實現該接口的枚舉，以此將元素進行分組。達到將枚舉元素進行分組。
6. 使用EnumSet 代替標誌。enum 要求其成員都是唯一的，但是enum 中不能刪除添加元素。
7. EnumMap 的key 是enum ，value 是任何其他Object 對象。
8. enum 允許程序員為eunm 實例編寫方法。所以可以為每個enum 實例賦予各自不同的行為。
9. 使用enum 的職責鏈(Chain of Responsibility) . 這個關係到設計模式的職責鏈模式。以多種不同的方法來解決一個問題。然後將他們鏈接在一起。當一個請求到來時，遍歷這個鏈，直到鏈中的某個解決方案能夠處理該請求。
10. 使用enum 的狀態機
11. 使用enum 多路分發
java枚舉類怎麼寫
枚舉（enum）類型是Java 5新增的特性，它是一種新的類型，允許用常量來表示特定的數據片斷，而且全部都以類型安全的形式來表示。
1、常量的使用
在JDK1.5之前，我們定義常量都是：public static fianl….。現在好了，有了枚舉，可以把相關的常量分組到一個枚舉類型里，而且枚舉提供了比常量更多的方法。
1234567
package com; public enum Color { RED, GREEN, BLANK, YELLOW }
使用
123456789101112131415161718192021
package com; public class B { public static void main(String[] args) { System.out.println( isRed( Color.BLANK ) ) ; //結果： false System.out.println( isRed( Color.RED ) ) ; //結果： true } static boolean isRed( Color color ){ if ( Color.RED.equals( color )) { return true ; } return false ; } }
或者 switch 的使用
12345678910111213141516171819202122232425
package com; public class B { public static void main(String[] args) { showColor( Color.RED ); } static void showColor(Color color){ switch ( color ) { case BLANK: System.out.println( color ); break; case RED : System.out.println( color ); break; default: System.out.println( color ); break; } }}
2、自定義函數
package com; public enum Color { RED(“紅色”, 1), GREEN(“綠色”, 2), BLANK(“白色”, 3), YELLO(“黃色”, 4); private String name ; private int index ; private Color( String name , int index ){ this.name = name ; this.index = index ; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getIndex() { return index; } public void setIndex(int index) { this.index = index; } }
使用
package com; public class B { public static void main(String[] args) { //輸出某一枚舉的值 System.out.println( Color.RED.getName() ); System.out.println( Color.RED.getIndex() ); //遍歷所有的枚舉 for( Color color : Color.values()){ System.out.println( color + ” name: ” + color.getName() + ” index: ” + color.getIndex() ); } } }
結果
紅色
1
RED name: 紅色 index: 1
GREEN name: 綠色 index: 2
BLANK name: 白色 index: 3
YELLO name: 黃色 index: 4
總結：
1、枚舉的本質是類，在沒有枚舉之前，仍然可以按照java最基本的編程手段來解決需要用到枚舉的地方。枚舉屏蔽了枚舉值的類型信息，不像在用public static final定義變量必須指定類型。枚舉是用來構建常量數據結構的模板，這個模板可擴展。枚舉的使用增強了程序的健壯性，比如在引用一個不存在的枚舉值的時候，編譯器會報錯。枚舉的更多用法還需要在開發中去研究創造，Java5、Java6增加了不少新的特性，技術在升級，對程序員來說就要學習，如果你熱愛java的話。否則別人用到新特性的代碼你看不懂，那才叫鬱悶。
2、枚舉在Java家族中只佔了很小的一塊比重，所以我在項目中用枚舉的地方不是很多，畢竟，一個項目是很多人開發維護的，用一個陌生的東西，會給其他的同事造成閱讀困難。所以常量大都是用public static final 來定義的。
原創文章，作者：FF9YJ，如若轉載，請註明出處：https://www.506064.com/zh-hant/n/128651.html
微信掃一掃 
支付寶掃一掃 