深入理解 Java 列舉

:notebook: 本文已歸檔到：「blog」

:keyboard: 本文中的示例程式碼已歸檔到：「javacore」

簡介

enum 的全稱為 enumeration， 是 JDK5 中引入的特性。

在 Java 中，被 enum 關鍵字修飾的型別就是列舉型別。形式如下：

enum ColorEn { RED, GREEN, BLUE }
複製程式碼

列舉的好處：可以將常量組織起來，統一進行管理。

列舉的典型應用場景：錯誤碼、狀態機等。

列舉的本質

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 {};
}
複製程式碼

:bulb: 說明：

從上面的例子可以看出：

列舉的本質是 java.lang.Enum 的子類。

儘管 enum 看起來像是一種新的資料型別，事實上，enum 是一種受限制的類，並且具有自己的方法。列舉這種特殊的類因為被修飾為 final，所以不能繼承其他類。

定義的列舉值，會被預設修飾為 public static final ，從修飾關鍵字，即可看出列舉值本質上是靜態常量。

列舉的方法

在 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
複製程式碼

列舉的特性

列舉的特性，歸結起來就是一句話：

除了不能繼承，基本上可以將 enum 看做一個常規的類。

但是這句話需要拆分去理解，讓我們細細道來。

基本特性

如果列舉中沒有定義方法，也可以在最後一個例項後面加逗號、分號或什麼都不加。

如果列舉中沒有定義方法，列舉值預設為從 0 開始的有序數值。以 Color 列舉型別舉例，它的列舉常量依次為 RED：0，GREEN：1，BLUE：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
複製程式碼

注：上面的例子並不可取，僅僅是為了展示列舉支援定義各種方法。正確的例子情況錯誤碼示例

列舉可以實現介面

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;
    }
}
複製程式碼

列舉不可以繼承

enum 不可以繼承另外一個類，當然，也不能繼承另一個 enum 。

因為 enum 實際上都繼承自 java.lang.Enum 類，而 Java 不支援多重繼承，所以 enum 不能再繼承其他類，當然也不能繼承另一個 enum。

列舉的應用

組織常量

在 JDK5 之前，在 Java 中定義常量都是public static final TYPE a; 這樣的形式。有了列舉，你可以將有關聯關係的常量組織起來，使程式碼更加易讀、安全，並且還可以使用列舉提供的方法。

下面三種宣告方式是等價的：

enum Color { RED, GREEN, BLUE }
enum Color { RED, GREEN, BLUE, }
enum Color { RED, GREEN, BLUE; }
複製程式碼

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:
// 紅燈停
複製程式碼

錯誤碼

列舉常被用於定義程式錯誤碼。下面是一個簡單示例：

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'}
複製程式碼

組織列舉

可以將型別相近的列舉通過介面或類組織起來，但是一般用介面方式進行組織。

原因是：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:
// 土豆
// 西紅柿
複製程式碼

策略列舉

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));
複製程式碼

列舉實現單例模式

單例模式是最常用的設計模式。

單例模式在併發環境下存線上程安全問題。

為了執行緒安全問題，傳統做法有以下幾種：

• 餓漢式載入
• 懶漢式 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 列舉的特性講解很仔細，其中對於列舉實現單例和傳統單例實現方式說的尤為細緻。

列舉工具類

Java 中提供了兩個方便操作 enum 的工具類——EnumSet 和 EnumMap。

EnumSet

EnumSet 是列舉型別的高效能 Set 實現。它要求放入它的列舉常量必須屬於同一列舉型別。

主要介面：

• noneOf - 建立一個具有指定元素型別的空 EnumSet
• allOf - 建立一個指定元素型別幷包含所有列舉值的 EnumSet
• range - 建立一個包括列舉值中指定範圍元素的 EnumSet
• complementOf - 初始集合包括指定集合的補集
• of - 建立一個包括引數中所有元素的 EnumSet
• copyOf - 建立一個包含引數容器中的所有元素的 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());
        }
    }
}
複製程式碼

EnumMap

EnumMap 是專門為列舉型別量身定做的 Map 實現。雖然使用其它的 Map 實現（如 HashMap）也能完成列舉型別例項到值得對映，但是使用 EnumMap 會更加高效：它只能接收同一列舉型別的例項作為鍵值，並且由於列舉型別例項的數量相對固定並且有限，所以 EnumMap 使用陣列來存放與列舉型別對應的值。這使得 EnumMap 的效率非常高。

主要介面：

• size - 返回鍵值對數
• containsValue - 是否存在指定的 value
• containsKey - 是否存在指定的 key
• get - 根據指定 key 獲取 value
• put - 取出指定的鍵值對
• remove - 刪除指定 key
• putAll - 批量取出鍵值對
• 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 原理做了較為詳細的介紹。

小結

參考資料

• Java 程式設計思想
• JAVA 核心技術（卷 1）
• Effective java
• 深入理解 Java 列舉型別(enum)
• droidyue.com/blog/2016/1…