📓 本文已歸檔到:「javacore」
🔁 本文中的示例代碼已歸檔到:「javacore」
1. 簡介
enum
的全稱爲 enumeration, 是 JDK5 中引入的特性。
在 Java 中,被 enum
關鍵字修飾的類型就是枚舉類型。形式如下:
enum ColorEn { RED, GREEN, BLUE }
枚舉的好處:可以將常量組織起來,統一進行管理。
枚舉的典型應用場景:錯誤碼、狀態機等。
2. 枚舉的本質
java.lang.Enum
類聲明
public abstract class Enum<E extends Enum<E>>
implements Comparable<E>, Serializable { ... }
新建一個 ColorEn.java 文件,內容如下:
package io.github.dunwu.javacore.enumeration;
public enum ColorEn {
RED,YELLOW,BLUE
}
執行 javac ColorEn.java
命令,生成 ColorEn.class 文件。
然後執行 javap ColorEn.class
命令,輸出如下內容:
Compiled from "ColorEn.java"
public final class io.github.dunwu.javacore.enumeration.ColorEn extends java.lang.Enum<io.github.dunwu.javacore.enumeration.ColorEn> {
public static final io.github.dunwu.javacore.enumeration.ColorEn RED;
public static final io.github.dunwu.javacore.enumeration.ColorEn YELLOW;
public static final io.github.dunwu.javacore.enumeration.ColorEn BLUE;
public static io.github.dunwu.javacore.enumeration.ColorEn[] values();
public static io.github.dunwu.javacore.enumeration.ColorEn valueOf(java.lang.String);
static {};
}
💡 說明:
從上面的例子可以看出:
枚舉的本質是
java.lang.Enum
的子類。儘管
enum
看起來像是一種新的數據類型,事實上,enum 是一種受限制的類,並且具有自己的方法。枚舉這種特殊的類因爲被修飾爲final
,所以不能繼承其他類。定義的枚舉值,會被默認修飾爲
public static final
,從修飾關鍵字,即可看出枚舉值本質上是靜態常量。
3. 枚舉的方法
在 enum 中,提供了一些基本方法:
values()
:返回 enum 實例的數組,而且該數組中的元素嚴格保持在 enum 中聲明時的順序。name()
:返回實例名。ordinal()
:返回實例聲明時的次序,從 0 開始。getDeclaringClass()
:返回實例所屬的 enum 類型。equals()
:判斷是否爲同一個對象。
可以使用 ==
來比較enum
實例。
此外,java.lang.Enum
實現了Comparable
和 Serializable
接口,所以也提供 compareTo()
方法。
例:展示 enum 的基本方法
public class EnumMethodDemo {
enum Color {RED, GREEN, BLUE;}
enum Size {BIG, MIDDLE, SMALL;}
public static void main(String args[]) {
System.out.println("=========== Print all Color ===========");
for (Color c : Color.values()) {
System.out.println(c " ordinal: " c.ordinal());
}
System.out.println("=========== Print all Size ===========");
for (Size s : Size.values()) {
System.out.println(s " ordinal: " s.ordinal());
}
Color green = Color.GREEN;
System.out.println("green name(): " green.name());
System.out.println("green getDeclaringClass(): " green.getDeclaringClass());
System.out.println("green hashCode(): " green.hashCode());
System.out.println("green compareTo Color.GREEN: " green.compareTo(Color.GREEN));
System.out.println("green equals Color.GREEN: " green.equals(Color.GREEN));
System.out.println("green equals Size.MIDDLE: " green.equals(Size.MIDDLE));
System.out.println("green equals 1: " green.equals(1));
System.out.format("green == Color.BLUE: %b\n", green == Color.BLUE);
}
}
輸出
=========== Print all Color ===========
RED ordinal: 0
GREEN ordinal: 1
BLUE ordinal: 2
=========== Print all Size ===========
BIG ordinal: 0
MIDDLE ordinal: 1
SMALL ordinal: 2
green name(): GREEN
green getDeclaringClass(): class org.zp.javase.enumeration.EnumDemo$Color
green hashCode(): 460141958
green compareTo Color.GREEN: 0
green equals Color.GREEN: true
green equals Size.MIDDLE: false
green equals 1: false
green == Color.BLUE: false
4. 枚舉的特性
枚舉的特性,歸結起來就是一句話:
除了不能繼承,基本上可以將
enum
看做一個常規的類。
但是這句話需要拆分去理解,讓我們細細道來。
4.1. 基本特性
如果枚舉中沒有定義方法,也可以在最後一個實例後面加逗號、分號或什麼都不加。
如果枚舉中沒有定義方法,枚舉值默認爲從 0 開始的有序數值。以 Color 枚舉類型舉例,它的枚舉常量依次爲 RED:0,GREEN:1,BLUE:2
。
4.2. 枚舉可以添加方法
在概念章節提到了,枚舉值默認爲從 0 開始的有序數值 。那麼問題來了:如何爲枚舉顯式的賦值。
(1)Java 不允許使用 =
爲枚舉常量賦值
如果你接觸過 C/C ,你肯定會很自然的想到賦值符號 =
。在 C/C 語言中的 enum,可以用賦值符號=
顯式的爲枚舉常量賦值;但是 ,很遺憾,Java 語法中卻不允許使用賦值符號 =
爲枚舉常量賦值。
例:C/C 語言中的枚舉聲明
typedef enum {
ONE = 1,
TWO,
THREE = 3,
TEN = 10
} Number;
(2)枚舉可以添加普通方法、靜態方法、抽象方法、構造方法
Java 雖然不能直接爲實例賦值,但是它有更優秀的解決方案:爲 enum 添加方法來間接實現顯式賦值。
創建 enum
時,可以爲其添加多種方法,甚至可以爲其添加構造方法。
注意一個細節:如果要爲 enum 定義方法,那麼必須在 enum 的最後一個實例尾部添加一個分號。此外,在 enum 中,必須先定義實例,不能將字段或方法定義在實例前面。否則,編譯器會報錯。
例:全面展示如何在枚舉中定義普通方法、靜態方法、抽象方法、構造方法
public enum ErrorCodeEn {
OK(0) {
@Override
public String getDescription() {
return "成功";
}
},
ERROR_A(100) {
@Override
public String getDescription() {
return "錯誤A";
}
},
ERROR_B(200) {
@Override
public String getDescription() {
return "錯誤B";
}
};
private int code;
// 構造方法:enum的構造方法只能被聲明爲private權限或不聲明權限
private ErrorCodeEn(int number) { // 構造方法
this.code = number;
}
public int getCode() { // 普通方法
return code;
} // 普通方法
public abstract String getDescription(); // 抽象方法
public static void main(String args[]) { // 靜態方法
for (ErrorCodeEn s : ErrorCodeEn.values()) {
System.out.println("code: " s.getCode() ", description: " s.getDescription());
}
}
}
// Output:
// code: 0, description: 成功
// code: 100, description: 錯誤A
// code: 200, description: 錯誤B
注:上面的例子並不可取,僅僅是爲了展示枚舉支持定義各種方法。正確的例子情況錯誤碼示例
4.3. 枚舉可以實現接口
enum
可以像一般類一樣實現接口。
同樣是實現上一節中的錯誤碼枚舉類,通過實現接口,可以約束它的方法。
public interface INumberEnum {
int getCode();
String getDescription();
}
public enum ErrorCodeEn2 implements INumberEnum {
OK(0, "成功"),
ERROR_A(100, "錯誤A"),
ERROR_B(200, "錯誤B");
ErrorCodeEn2(int number, String description) {
this.code = number;
this.description = description;
}
private int code;
private String description;
@Override
public int getCode() {
return code;
}
@Override
public String getDescription() {
return description;
}
}
4.4. 枚舉不可以繼承
enum 不可以繼承另外一個類,當然,也不能繼承另一個 enum 。
因爲 enum
實際上都繼承自 java.lang.Enum
類,而 Java 不支持多重繼承,所以 enum
不能再繼承其他類,當然也不能繼承另一個 enum
。
5. 枚舉的應用
5.1. 組織常量
在 JDK5 之前,在 Java 中定義常量都是public static final TYPE a;
這樣的形式。有了枚舉,你可以將有關聯關係的常量組織起來,使代碼更加易讀、安全,並且還可以使用枚舉提供的方法。
下面三種聲明方式是等價的:
enum Color { RED, GREEN, BLUE }
enum Color { RED, GREEN, BLUE, }
enum Color { RED, GREEN, BLUE; }
5.2. switch 狀態機
我們經常使用 switch 語句來寫狀態機。JDK7 以後,switch 已經支持 int
、char
、String
、enum
類型的參數。這幾種類型的參數比較起來,使用枚舉的 switch 代碼更具有可讀性。
public class StateMachineDemo {
public enum Signal {
GREEN, YELLOW, RED
}
public static String getTrafficInstruct(Signal signal) {
String instruct = "信號燈故障";
switch (signal) {
case RED:
instruct = "紅燈停";
break;
case YELLOW:
instruct = "黃燈請注意";
break;
case GREEN:
instruct = "綠燈行";
break;
default:
break;
}
return instruct;
}
public static void main(String[] args) {
System.out.println(getTrafficInstruct(Signal.RED));
}
}
// Output:
// 紅燈停
5.3. 錯誤碼
枚舉常被用於定義程序錯誤碼。下面是一個簡單示例:
public class ErrorCodeEnumDemo {
enum ErrorCodeEn {
OK(0, "成功"),
ERROR_A(100, "錯誤A"),
ERROR_B(200, "錯誤B");
ErrorCodeEn(int number, String msg) {
this.code = number;
this.msg = msg;
}
private int code;
private String msg;
public int getCode() {
return code;
}
public String getMsg() {
return msg;
}
@Override
public String toString() {
return "ErrorCodeEn{" "code=" code ", msg='" msg '\'' '}';
}
public static String toStringAll() {
StringBuilder sb = new StringBuilder();
sb.append("ErrorCodeEn All Elements: [");
for (ErrorCodeEn code : ErrorCodeEn.values()) {
sb.append(code.getCode()).append(", ");
}
sb.append("]");
return sb.toString();
}
}
public static void main(String[] args) {
System.out.println(ErrorCodeEn.toStringAll());
for (ErrorCodeEn s : ErrorCodeEn.values()) {
System.out.println(s);
}
}
}
// Output:
// ErrorCodeEn All Elements: [0, 100, 200, ]
// ErrorCodeEn{code=0, msg='成功'}
// ErrorCodeEn{code=100, msg='錯誤A'}
// ErrorCodeEn{code=200, msg='錯誤B'}
5.4. 組織枚舉
可以將類型相近的枚舉通過接口或類組織起來,但是一般用接口方式進行組織。
原因是:Java 接口在編譯時會自動爲 enum 類型加上public static
修飾符;Java 類在編譯時會自動爲 enum
類型加上 static 修飾符。看出差異了嗎?沒錯,就是說,在類中組織 enum
,如果你不給它修飾爲 public
,那麼只能在本包中進行訪問。
例:在接口中組織 enum
public class EnumInInterfaceDemo {
public interface INumberEnum {
int getCode();
String getDescription();
}
public interface Plant {
enum Vegetable implements INumberEnum {
POTATO(0, "土豆"),
TOMATO(0, "西紅柿");
Vegetable(int number, String description) {
this.code = number;
this.description = description;
}
private int code;
private String description;
@Override
public int getCode() {
return this.code;
}
@Override
public String getDescription() {
return this.description;
}
}
enum Fruit implements INumberEnum {
APPLE(0, "蘋果"),
ORANGE(0, "桔子"),
BANANA(0, "香蕉");
Fruit(int number, String description) {
this.code = number;
this.description = description;
}
private int code;
private String description;
@Override
public int getCode() {
return this.code;
}
@Override
public String getDescription() {
return this.description;
}
}
}
public static void main(String[] args) {
for (Plant.Fruit f : Plant.Fruit.values()) {
System.out.println(f.getDescription());
}
}
}
// Output:
// 蘋果
// 桔子
// 香蕉
例:在類中組織 enum
本例和上例效果相同。
public class EnumInClassDemo {
public interface INumberEnum {
int getCode();
String getDescription();
}
public static class Plant2 {
enum Vegetable implements INumberEnum {
// 略,與上面完全相同
}
enum Fruit implements INumberEnum {
// 略,與上面完全相同
}
}
// 略
}
// Output:
// 土豆
// 西紅柿
5.5. 策略枚舉
Effective Java 中展示了一種策略枚舉。這種枚舉通過枚舉嵌套枚舉的方式,將枚舉常量分類處理。
這種做法雖然沒有 switch 語句簡潔,但是更加安全、靈活。
例:EffectvieJava 中的策略枚舉範例
enum PayrollDay {
MONDAY(PayType.WEEKDAY), TUESDAY(PayType.WEEKDAY), WEDNESDAY(
PayType.WEEKDAY), THURSDAY(PayType.WEEKDAY), FRIDAY(PayType.WEEKDAY), SATURDAY(
PayType.WEEKEND), SUNDAY(PayType.WEEKEND);
private final PayType payType;
PayrollDay(PayType payType) {
this.payType = payType;
}
double pay(double hoursWorked, double payRate) {
return payType.pay(hoursWorked, payRate);
}
// 策略枚舉
private enum PayType {
WEEKDAY {
double overtimePay(double hours, double payRate) {
return hours <= HOURS_PER_SHIFT ? 0 : (hours - HOURS_PER_SHIFT)
* payRate / 2;
}
},
WEEKEND {
double overtimePay(double hours, double payRate) {
return hours * payRate / 2;
}
};
private static final int HOURS_PER_SHIFT = 8;
abstract double overtimePay(double hrs, double payRate);
double pay(double hoursWorked, double payRate) {
double basePay = hoursWorked * payRate;
return basePay overtimePay(hoursWorked, payRate);
}
}
}
測試
System.out.println("時薪100的人在週五工作8小時的收入:" PayrollDay.FRIDAY.pay(8.0, 100));
System.out.println("時薪100的人在週六工作8小時的收入:" PayrollDay.SATURDAY.pay(8.0, 100));
5.6. 枚舉實現單例模式
單例模式是最常用的設計模式。
單例模式在併發環境下存在線程安全問題。
爲了線程安全問題,傳統做法有以下幾種:
- 餓漢式加載
- 懶漢式 synchronize 和雙重檢查
- 利用 java 的靜態加載機制
相比上述的方法,使用枚舉也可以實現單例,而且還更加簡單:
public class SingleEnumDemo {
public enum SingleEn {
INSTANCE;
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public static void main(String[] args) {
SingleEn.INSTANCE.setName("zp");
System.out.println(SingleEn.INSTANCE.getName());
}
}
擴展閱讀:深入理解 Java 枚舉類型(enum)
這篇文章對於 Java 枚舉的特性講解很仔細,其中對於枚舉實現單例和傳統單例實現方式說的尤爲細緻。
6. 枚舉工具類
Java 中提供了兩個方便操作 enum 的工具類——EnumSet
和 EnumMap
。
6.1. EnumSet
EnumSet
是枚舉類型的高性能 Set
實現。它要求放入它的枚舉常量必須屬於同一枚舉類型。
主要接口:
noneOf
- 創建一個具有指定元素類型的空 EnumSetallOf
- 創建一個指定元素類型幷包含所有枚舉值的 EnumSetrange
- 創建一個包括枚舉值中指定範圍元素的 EnumSetcomplementOf
- 初始集合包括指定集合的補集of
- 創建一個包括參數中所有元素的 EnumSetcopyOf
- 創建一個包含參數容器中的所有元素的 EnumSet
示例:
public class EnumSetDemo {
public static void main(String[] args) {
System.out.println("EnumSet展示");
EnumSet<ErrorCodeEn> errSet = EnumSet.allOf(ErrorCodeEn.class);
for (ErrorCodeEn e : errSet) {
System.out.println(e.name() " : " e.ordinal());
}
}
}
6.2. EnumMap
EnumMap
是專門爲枚舉類型量身定做的 Map
實現。雖然使用其它的 Map 實現(如 HashMap)也能完成枚舉類型實例到值得映射,但是使用 EnumMap 會更加高效:它只能接收同一枚舉類型的實例作爲鍵值,並且由於枚舉類型實例的數量相對固定並且有限,所以 EnumMap 使用數組來存放與枚舉類型對應的值。這使得 EnumMap 的效率非常高。
主要接口:
size
- 返回鍵值對數containsValue
- 是否存在指定的 valuecontainsKey
- 是否存在指定的 keyget
- 根據指定 key 獲取 valueput
- 取出指定的鍵值對remove
- 刪除指定 keyputAll
- 批量取出鍵值對clear
- 清除數據keySet
- 獲取 key 集合values
- 返回所有
示例:
public class EnumMapDemo {
public enum Signal {
GREEN, YELLOW, RED
}
public static void main(String[] args) {
System.out.println("EnumMap展示");
EnumMap<Signal, String> errMap = new EnumMap(Signal.class);
errMap.put(Signal.RED, "紅燈");
errMap.put(Signal.YELLOW, "黃燈");
errMap.put(Signal.GREEN, "綠燈");
for (Iterator<Map.Entry<Signal, String>> iter = errMap.entrySet().iterator(); iter.hasNext();) {
Map.Entry<Signal, String> entry = iter.next();
System.out.println(entry.getKey().name() " : " entry.getValue());
}
}
}
擴展閱讀:深入理解 Java 枚舉類型(enum)
這篇文章中對 EnumSet 和 EnumMap 原理做了較爲詳細的介紹。
7. 小結
8. 參考資料
- Java 編程思想
- JAVA 核心技術(卷 1)
- Effective java
- 深入理解 Java 枚舉類型(enum)
- https://droidyue.com/blog/2016/11/29/dive-into-enum/