Java 枚舉

知識點

概念

enum

的全稱為 enumeration，是 JDK 1.5 中引入的新特性。

在Java中，被

enum

關鍵字修飾的類型就是枚舉類型。形式如下：

enum Color { RED, GREEN, BLUE }

如果枚舉不添加任何方法，枚舉值預設為從0開始的有序數值。以 Color 枚舉類型舉例，它的枚舉常量依次為

RED：0，GREEN：1，BLUE：2

。

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

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

枚舉類型的本質

盡管

enum

看起來像是一種新的資料類型，事實上，enum是一種受限制的類，并且具有自己的方法。

建立enum時，編譯器會為你生成一個相關的類，這個類繼承自

java.lang.Enum

java.lang.Enum

類聲明

public abstract class Enum<E extends Enum<E>>
        implements Comparable<E>, Serializable { ... }

枚舉的方法

在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開始的有序數值。那麼問題來了：如何為枚舉顯示的指派。

Java 不允許使用 = 為枚舉常量指派

如果你接觸過C/C++，你肯定會很自然的想到指派符号

。在C/C++語言中的enum，可以用指派符号

顯示的為枚舉常量指派；但是，很遺憾，Java 文法中卻不允許使用指派符号

為枚舉常量指派。

例：C/C++ 語言中的枚舉聲明

typedef enum{
    ONE = 1,
    TWO,
    THREE = 3,
    TEN = 10
} Number;

枚舉可以添加普通方法、靜态方法、抽象方法、構造方法

Java 雖然不能直接為執行個體指派，但是它有更優秀的解決方案：為 enum 添加方法來間接實作顯示指派。

建立

enum

時，可以為其添加多種方法，甚至可以為其添加構造方法。

注意一個細節：如果要為enum定義方法，那麼必須在enum的最後一個執行個體尾部添加一個分号。此外，在enum中，必須先定義執行個體，不能将字段或方法定義在執行個體前面。否則，編譯器會報錯。

例：全面展示如何在枚舉中定義普通方法、靜态方法、抽象方法、構造方法

public enum ErrorCode {
    OK(0) {
        public String getDescription() {
            return "成功";
        }
    },
    ERROR_A(100) {
        public String getDescription() {
            return "錯誤A";
        }
    },
    ERROR_B(200) {
        public String getDescription() {
            return "錯誤B";
        }
    };

    private int code;

    // 構造方法：enum的構造方法隻能被聲明為private權限或不聲明權限
    private ErrorCode(int number) { // 構造方法
        this.code = number;
    }
    public int getCode() { // 普通方法
        return code;
    } // 普通方法
    public abstract String getDescription(); // 抽象方法
    public static void main(String args[]) { // 靜态方法
        for (ErrorCode s : ErrorCode.values()) {
            System.out.println("code: " + s.getCode() + ", description: " + s.getDescription());
        }
    }
}

注：上面的例子并不可取，僅僅是為了展示枚舉支援定義各種方法。下面是一個簡化的例子

例：一個錯誤碼枚舉類型的定義

本例和上例的執行結果完全相同。

public enum ErrorCodeEn {
    OK(0, "成功"),
    ERROR_A(100, "錯誤A"),
    ERROR_B(200, "錯誤B");

    ErrorCodeEn(int number, String description) {
        this.code = number;
        this.description = description;
    }
    private int code;
    private String description;
    public int getCode() {
        return code;
    }
    public String getDescription() {
        return description;
    }
    public static void main(String args[]) { // 靜态方法
        for (ErrorCodeEn s : ErrorCodeEn.values()) {
            System.out.println("code: " + s.getCode() + ", description: " + s.getDescription());
        }
    }
}

枚舉可以實作接口

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

枚舉的應用場景

組織常量

在JDK1.5 之前，在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代碼更具有可讀性。

enum Signal {RED, YELLOW, GREEN}

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;
}

組織枚舉

可以将類型相近的枚舉通過接口或類組織起來。

但是一般用接口方式進行組織。

原因是：Java接口在編譯時會自動為enum類型加上

public static

修飾符；Java類在編譯時會自動為

enum

類型加上static修飾符。看出差異了嗎？沒錯，就是說，在類中組織

enum

，如果你不給它修飾為

public

，那麼隻能在本包中進行通路。

例：在接口中組織 enum

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 0;
        }

        @Override
        public String getDescription() {
            return null;
        }
    }

    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 0;
        }

        @Override
        public String getDescription() {
            return null;
        }
    }
}

例：在類中組織 enum

本例和上例效果相同。

public class Plant2 {
    public enum Vegetable implements INumberEnum {...}  // 省略代碼
    public enum Fruit implements INumberEnum {...} // 省略代碼
}

政策枚舉

EffectiveJava中展示了一種政策枚舉。這種枚舉通過枚舉嵌套枚舉的方式，将枚舉常量分類處理。

這種做法雖然沒有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));

EnumSet和EnumMap

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

EnumSet

是枚舉類型的高性能

Set

實作。它要求放入它的枚舉常量必須屬于同一枚舉類型。

EnumMap

是專門為枚舉類型量身定做的

Map

實作。雖然使用其它的 Map 實作（如HashMap）也能完成枚舉類型執行個體到值得映射，但是使用 EnumMap 會更加高效：它隻能接收同一枚舉類型的執行個體作為鍵值，并且由于枚舉類型執行個體的數量相對固定并且有限，是以 EnumMap 使用數組來存放與枚舉類型對應的值。這使得 EnumMap 的效率非常高。

// EnumSet的使用
System.out.println("EnumSet展示");
EnumSet<ErrorCodeEn> errSet = EnumSet.allOf(ErrorCodeEn.class);
for (ErrorCodeEn e : errSet) {
    System.out.println(e.name() + " : " + e.ordinal());
}

// EnumMap的使用
System.out.println("EnumMap展示");
EnumMap<StateMachine.Signal, String> errMap = new EnumMap(StateMachine.Signal.class);
errMap.put(StateMachine.Signal.RED, "紅燈");
errMap.put(StateMachine.Signal.YELLOW, "黃燈");
errMap.put(StateMachine.Signal.GREEN, "綠燈");
for (Iterator<Map.Entry<StateMachine.Signal, String>> iter = errMap.entrySet().iterator(); iter.hasNext();) {
    Map.Entry<StateMachine.Signal, String> entry = iter.next();
    System.out.println(entry.getKey().name() + " : " + entry.getValue());
}

Java 枚舉Java 枚舉

Java 枚舉

知識點

概念

枚舉類型的本質

枚舉的方法

枚舉的特性

枚舉可以添加方法

Java 不允許使用 = 為枚舉常量指派

枚舉可以添加普通方法、靜态方法、抽象方法、構造方法

枚舉可以實作接口

枚舉不可以繼承

枚舉的應用場景

組織常量

枚舉聲明的格式

switch 狀态機

組織枚舉

政策枚舉

EnumSet和EnumMap

繼續閱讀

Java String.format方法的簡單使用

neo4j之cypher使用文檔

C經典書籍筆記——C陷阱與缺陷②(文法陷阱之優先級)一、錯誤案列二、優先級規律

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

線性表之順序表的實作

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

C++判斷素數、求最大公約數代碼判斷一個數是否為素數求兩個數的最大公約數

SequoiaDB巨杉資料庫C++驅動概述

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method