你可能不瞭解的java列舉

apocelipes發表於2020-09-02

列舉在java裡也算個老生長談的內容了，每當遇到一組需要類舉的資料時我們都會自然而然地使用列舉型別：

public enum Color {
    RED, GREEN, BLUE, YELLOW;

    public static void main(String[] args) {
        Color red = Color.RED;
        Color redAnother = Color.RED;
        Color blue = Color.BLUE;

        System.out.println(red.equals(redAnother)); // true
        System.out.println(red.equals(blue)); // false
    }
}

當然今天我們要探討的並非是java中enum的基礎語法，本次的主題將會深入enum的本質，並探討部分高階用法。本文基於Oracle JDK 14.0.2和jad v1.5.8e（由於jad已經很久未進行更新，對於新版本的jdk支援不是很完善，但單純分析enum和interface已經足夠）。

自定義列舉值背後的祕密

列舉預設的值是從0開始遞增的數值，通常來說這完全夠用了。不過java中還允許我們對列舉的值做個性化定製，例如：

// 我們不僅想用英語的方位，同時還想取得對應的本地化名稱（這裡是中文）
enum Direction {
    EAST("東"),
    WEST("西"),
    NORTH("北"),
    SOUTH("南");

    private final String name;

    // 注意是private
    private Direction(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }
}

public class Test {
    public static void main(String[] args) {
        for (var v : Direction.values()) {
            System.out.println(v.toString() + "-->" + v.getName());
        }
    }
}

編譯並執行程式，你將會得到下面這樣的結果：

EAST-->東
WEST-->西
NORTH-->北
SOUTH-->南

很多教程到此就結束了，點到為止，對於列舉值後面的圓括號有什麼作用，為什麼建構函式需要private修飾都一筆帶過甚至連解釋說明都沒給出。然而理解這些卻是我們進一步學習列舉的高階用法的前提。

不過沒關係，我們可以自己動手一探究竟，比如看看反編譯後的程式碼，從編譯器處理列舉型別的方法中一探究竟。這裡我們將會利用jad，具體的使用教程參考園內其他優秀文章，本文不進行贅述，我們直接看反編譯後的結果：

final class Direction extends Enum
{

    /* 省略部分無關緊要的方法 */

    private Direction(String s, int i, String s1)
    {
        super(s, i);
        name = s1;
    }

    public String getName() // 這是我們自定義的getter
    {
        return name;
    }

    public static final Direction EAST;
    public static final Direction WEST;
    public static final Direction NORTH;
    public static final Direction SOUTH;
    private final String name;
    // 省略不重要的部分欄位

    static 
    {
        EAST = new Direction("EAST", 0, "\u4E1C");
        WEST = new Direction("WEST", 1, "\u897F");
        NORTH = new Direction("NORTH", 2, "\u5317");
        SOUTH = new Direction("SOUTH", 3, "\u5357");
        // 省略部分欄位的初始化
    }
}

首先看到我們的enum是一個類，其次它繼承自java.lang.Enum（這意味著enum是無法顯式指定基類的），而我們在Direction的建構函式中呼叫了其父類的建構函式，通過閱讀文件可知，java.lang.Enum的建構函式是protected修飾的，也就是說對於java.lang包以外的使用者無法呼叫這個建構函式。同時文件也指出，該建構函式是由編譯器自動呼叫的。因此我們自己定義的enum的建構函式也是無法正常呼叫的，只能由編譯器用來初始化enum的列舉成員。既然本身無法被使用者呼叫那麼java乾脆直接不允許protected和public（default和private允許）修飾自定義enum型別的建構函式以免造成誤用。

另外我們的自定義建構函式其實是被編譯器進行了合成，除了自定義引數之外還有列舉成員的字串名稱以及一個從0開始的序號（可用ordinal方法獲取），前兩個引數編譯器會自動為我們新增，而自定義引數則是根據在我們給定的列舉成員後的圓括號裡的值傳遞給建構函式，簡單說就是：

EAST("東"),
WEST("西"),
NORTH("北"),
SOUTH("南");

// 轉換為（unicode字元被轉碼）
EAST = new Direction("EAST", 0, "\u4E1C");
WEST = new Direction("WEST", 1, "\u897F");
NORTH = new Direction("NORTH", 2, "\u5317");
SOUTH = new Direction("SOUTH", 3, "\u5357");

如果我需要更多欄位，只需要像這樣：

public enum Planet {
    // 帶有兩個自定義數值
    MERCURY (3.303e+23, 2.4397e6),
    VENUS   (4.869e+24, 6.0518e6),
    EARTH   (5.976e+24, 6.37814e6),
    MARS    (6.421e+23, 3.3972e6),
    JUPITER (1.9e+27,   7.1492e7),
    SATURN  (5.688e+26, 6.0268e7),
    URANUS  (8.686e+25, 2.5559e7),
    NEPTUNE (1.024e+26, 2.4746e7);

    // 儲存自定義值的欄位，不使用final也可以，但列舉值一般不應該發生改變
    private final double mass;   // in kilograms
    private final double radius; // in meters
    // 在這裡使用default的許可權控制，即package-private
    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }
    public double mass() { return mass; }
    public double radius() { return radius; }
}

這就是自定義列舉值背後的祕密。

至此我們的疑問幾乎都得到了解答，然而細心觀察就會發現，我們的列舉成員都是Direction的_靜態欄位_！因此我們不能把這些列舉成員當作型別來使用：

public void work(Direction.EAST e) {
    // 這是無法通過編譯的
}

靜態欄位很好理解，因為我們需要通過類名+列舉成員名Direction.WEST直接引用，但為什麼欄位型別要是Direction的呢？

彆著急，下一節答案就將揭曉。

為列舉新增抽象方法

這一節看起來很荒謬，抽象方法似乎和列舉八杆子打不到一塊兒去。可是仔細想一想，在上一節中我們已經為列舉新增了getter成員方法，這說明我們還可以為列舉新增其他的方法從而定製列舉型別的行為，以上一節的Planet為例，我們可以新增計算任意物體在某個行星表面所受重力和質量的大小：

public enum Planet {
    
    /* 定義列舉成員和初始化的相關重複程式碼，此處不再重複 */

    private double mass() { return mass; }
    private double radius() { return radius; }

    // universal gravitational constant  (m3 kg-1 s-2)
    public static final double G = 6.67300E-11;

    double surfaceGravity() {
        return G * mass / (radius * radius);
    }
    double surfaceWeight(double otherMass) {
        return otherMass * surfaceGravity();
    }
    public static void main(String[] args) {
        if (args.length != 1) {
            System.err.println("Usage: java Planet <earth_weight>");
            System.exit(-1);
        }
        double earthWeight = Double.parseDouble(args[0]);
        double mass = earthWeight/EARTH.surfaceGravity();
        for (Planet p : Planet.values())
           System.out.printf("Your weight on %s is %f%n",
                             p, p.surfaceWeight(mass));
    }
}

執行結果如下：

$ java Planet.java 70

Your weight on MERCURY is 26.443033
Your weight on VENUS is 63.349937
Your weight on EARTH is 70.000000
Your weight on MARS is 26.511603
Your weight on JUPITER is 177.139027
Your weight on SATURN is 74.621088
Your weight on URANUS is 63.358904
Your weight on NEPTUNE is 79.682965

既然能定製整個enum的行為，那是否意味著我們可以單獨定義列舉成員的行為呢，畢竟方法最終還是從列舉成員值身上進行呼叫的。

答案是肯定的，還記得在上一節最後部分編譯器是怎麼處理列舉成員的嗎？

EAST = new Direction("EAST", 0, "\u4E1C");
WEST = new Direction("WEST", 1, "\u897F");
NORTH = new Direction("NORTH", 2, "\u5317");
SOUTH = new Direction("SOUTH", 3, "\u5357");

沒錯，列舉成員本身也是enum物件的一個例項！而且這些列舉成員雖然是Direction型別的，但實際上還可以引用Direction的派生型別。

假設我們有一個Color型別的列舉，對於每個列舉成員我們都一個定製的print方法用於列印不同的資訊：

enum Color {
    RED{
        // 先不用管這是什麼語法，後面會解釋
        @Override
        public void print() {
            // Linux上輸出彩色字串
            System.out.println("\u001B[1;31m This is red text \u001B[0m");
        }
    },
    BLUE{
        @Override
        public void print() {
            System.out.println("\u001B[1;34m This is blue text \u001B[0m");
        }
    },
    GREEN{
        @Override
        public void print() {
            System.out.println("\u001B[1;32m This is green text \u001B[0m");
        }
    };

    // 列舉成員必須要覆寫的抽象方法
    public abstract void print();
}

public class Test {
    public static void main(String[] args) {
        for (var v : Color.values()) {
            v.print();
        }
    }
}

執行結果如下：

要想知道原理，我們還是得藉助jad，這是Color.class經過處理後的內容：

// 變成了抽象類
abstract class Color extends Enum
{
    // 建構函式
    private Color(String s, int i)
    {
        super(s, i);
    }

    public abstract void print();

    public static final Color RED;
    public static final Color BLUE;
    public static final Color GREEN;

    static 
    {
        // 重點從這開始
        RED = new Color("RED", 0) {

            public void print()
            {
                System.out.println("\033[1;31m This is red text \033[0m");
            }

        };
        BLUE = new Color("BLUE", 1) {

            public void print()
            {
                System.out.println("\033[1;34m This is blue text \033[0m");
            }

        };
        GREEN = new Color("GREEN", 2) {

            public void print()
            {
                System.out.println("\033[1;32m This is green text \033[0m");
            }

        };
    }
}

細心的讀者大概已經發現了，這不就是_匿名內部類_麼？說對了，我們的enum型別這次實際上變成了抽象類，而列舉成員則是繼承自Color的匿名內部類並實現了抽象方法。所以最開始我們用註釋標記的大括號其實可以理解成匿名類的類體。不過需要注意的是，雖然這裡顯式使用了new來建立了匿名內部類，但建構函式仍然是編譯器代為呼叫的。

如果想增加自定義的列舉資料呢？可以這樣做：

enum Color {
    RED(31){
        @Override
        public void print() {
            System.out.println("\u001B[1;31m This is red text \u001B[0m");
        }
    },
    BLUE(34){
        @Override
        public void print() {
            System.out.println("\u001B[1;34m This is blue text \u001B[0m");
        }
    },
    GREEN(32){
        @Override
        public void print() {
            System.out.println("\u001B[1;32m This is green text \u001B[0m");
        }
    };

    // color code
    private final int colorCode;
    private Color(int code) {
        colorCode = code;
    }
    public int getColorCode() {
        return colorCode;
    }

    public abstract void print();
}

我們看看編譯後的程式碼，限於篇幅，我只保留了重要的部分：

abstract class Color extends Enum
{

    /* 大量省略程式碼 */

    private Color(String s, int i, int j)
    {
        super(s, i);
        colorCode = j;
    }

    public abstract void print();

    public static final Color RED;
    public static final Color BLUE;
    public static final Color GREEN;
    private final int colorCode;

    static 
    {
        // 引數傳遞給了建構函式
        RED = new Color("RED", 0, 31) {

            public void print()
            {
                System.out.println("\033[1;31m This is red text \033[0m");
            }

        };
        BLUE = new Color("BLUE", 1, 34) {

            public void print()
            {
                System.out.println("\033[1;34m This is blue text \033[0m");
            }

        };
        GREEN = new Color("GREEN", 2, 32) {

            public void print()
            {
                System.out.println("\033[1;32m This is green text \033[0m");
            }

        };
    }
}

總結一下，對於一個enum型別來說，通常會有如下格式：

[public] enum NAME [implements XXX, ...] {
    VALUE1 [(自定義資料，格式和自定義建構函式函式的引數列表相同)]
    [{
        // 可以override或是追加新的method
    }],
    ...,
    VALUEN [(...)]
    [{
        // overrides or methods
    }];

    [儲存各種自定義資料的欄位，最好用final修飾]
    [
        // 自定義建構函式
        [private] NAME(和列舉成員中給出的圓括號內的內容一致) { /* 設定資料欄位 */ }
    ]

    [定義抽象方法或者重寫object/Enum的方法或是新增普通類方法]
}

給出的格式中用[]框住的部分都是可以省略的。

列舉和介面

在上一節的最後，我們看到enum其實還可以實現interface（畢竟本質上還是個class），所以上一節的例子可以這麼寫：

interface Printer {
    void print();
}

enum Color implements Printer {
    RED{
        @Override
        public void print() {
            System.out.println("\u001B[1;31m This is red text \u001B[0m");
        }
    },
    BLUE{
        @Override
        public void print() {
            System.out.println("\u001B[1;34m This is blue text \u001B[0m");
        }
    },
    GREEN{
        @Override
        public void print() {
            System.out.println("\u001B[1;32m This is green text \u001B[0m");
        }
    };
}

我個人更傾向於第二種方法，因為enum主要是資料的集合，而對於資料表現出的行為/模式儘量使用interface進行描述。

除此之外，enum還可以定義在iinterface中。假設我們有一個列舉表示從週一到週日，同時給定一個方法isRestDay判斷當前日期是否可以休息（比如有的人雙休有的人單休還有的人在週一或週五休息），不同型別的人對於周幾該休息將會產生不同的答案，因此將它抽象成介面再合適不過了：

interface Relaxable {
    enum Weekly {
        Mon, Tue, Wed, Thu, Fri, Sat, Sun
    }

    boolean isRestDay(Relaxable.Weekly day);
}

class PersonA implements Relaxable {
    @Override
    public boolean isRestDay(Relaxable.Weekly day) {
        return day.equals(Relaxable.Weekly.Sat) || day.equals(Relaxable.Weekly.Sun);
    }
}

class PersonB implements Relaxable {
    @Override
    public boolean isRestDay(Relaxable.Weekly day) {
        return day.equals(Relaxable.Weekly.Sun);
    }
}

public class Relax {
    public static void main(String[] args) {
        var a = new PersonA();
        var b = new PersonB();
        var day = Relaxable.Weekly.Sat;
        System.out.println(a.isRestDay(day)); // true
        System.out.println(b.isRestDay(day)); // false
    }
}

PersonA擁有一個美好的雙休，而可憐的PersonB卻要在週六加班！使用jad檢視生產的程式碼：

interface Relaxable
{
    public static final class Weekly extends Enum
    {

        /* 省略了部分程式碼 */

        public static final Weekly Mon;
        public static final Weekly Tue;
        public static final Weekly Wed;
        public static final Weekly Thu;
        public static final Weekly Fri;
        public static final Weekly Sat;
        public static final Weekly Sun;

        static 
        {
            Mon = new Weekly("Mon", 0);
            Tue = new Weekly("Tue", 1);
            Wed = new Weekly("Wed", 2);
            Thu = new Weekly("Thu", 3);
            Fri = new Weekly("Fri", 4);
            Sat = new Weekly("Sat", 5);
            Sun = new Weekly("Sun", 6);
        }

        private Weekly(String s, int i)
        {
            super(s, i);
        }
    }

    public abstract boolean isRestDay(Weekly weekly);
}

可以看出此時的enum僅僅只是interface中的一個靜態內部類而已。使用類似的方法可以藉由interface來組織多個不同但有弱關聯性的列舉型別，從而構成類似其他語言中namespace的組織結構。

當然，通常我們並不推薦用介面來組織多種不同的型別或是構成namespace，介面通常的作用是抽象出一組類的共同特性，或是讓不同的類之間可以遵守相同的協議從而簡化開發工作，主體應該是介面提供的方法以及這些方法所依賴的共通的一小部分資料型別（例如上例，雖然例子不是很好）;而final class則更適合組織不同資料型別和靜態常量，更進一步的理由超過了本文的探討範疇，你可以在園內搜尋相關文章進一步學習。

總結

在本文中，我們學到了：

如何新增列舉的自定義資料
為列舉新增建構函式和方法
用列舉實現介面
將列舉和介面組合使用

當然，依靠反編譯的程式碼來學習語言特性並不是一個值得推薦的選擇，但確實最直觀的最容易讓人理解底層原理的辦法。

長文難免會有疏漏之處，如有補充和指正歡迎指出！

Java列舉解讀
2020-09-13
Java
mac技巧|你可能不瞭解的實用操作~
2020-09-26
Mac
Java enum列舉類詳解列舉的常見用法
2021-01-04
Java
你可能不瞭解的 Promise 微任務型別
2022-05-28
Promise型別
Java 列舉 enum 詳解
2020-11-25
Java
JAVA列舉使用詳解
2016-05-17
Java
Day69.註解&列舉類的複習 -Java註解&列舉類
2020-10-12
Java
Java列舉
2018-11-20
Java
java中的列舉
2022-03-06
Java
Java列舉類、註解和反射
2021-05-11
Java反射
【Java基礎】列舉和註解
2016-06-28
Java
你瞭解Java反射嗎？
2019-09-18
Java反射
Java列舉類，你們用對了嗎？
2022-03-23
Java
Java 列舉(enum)
2019-01-19
Java
java列舉類
2020-11-18
Java
Java列舉使用
2017-10-24
Java
Java 列舉 switch的用法
2018-10-09
Java
Java基礎（十）——列舉與註解
2022-01-17
Java
java enum(列舉)使用詳解 + 總結
2016-07-04
Java
Java列舉型別enum的詳解及使用
2021-10-22
Java型別
Java列舉-通過值查詢對應的列舉
2022-01-30
Java
作為移動開發你不能不瞭解的編譯流程
2023-03-27
移動開發編譯
【java基礎】--Java列舉
2016-03-03
Java
你真的瞭解JS陣列的那些方法嗎？
2018-04-14
JS陣列
javascript哪些屬性是可列舉的
2017-04-14
JavaScript
js可列舉屬性的遍歷
2018-07-03
JS
java中的列舉型別
2018-10-26
Java型別
Java 列舉(enum) 詳解7種常見的用法
2021-09-09
Java
Java基礎--列舉
2019-04-11
Java
【java基礎】列舉
2021-08-05
Java
Java（4）列舉類
2020-11-19
Java
【java】【列舉使用技巧】
2020-10-30
Java
java列舉型別
2018-02-24
Java型別
java 列舉型別
2016-04-21
Java型別
關於 Linux 你可能不是非常瞭解的七件事
2017-10-05
Linux
你一定需要知道的高階JAVA列舉特性！
2021-01-13
Java
Java列舉類與註解詳解——一篇文章讀懂列舉類與註解詳
2021-06-02
Java
你應該瞭解的 Java SPI 機制
2020-02-24
Java