夯實Java基礎系列14：深刻理解Java枚舉類

時間  2020-07-22
標籤 夯實 java 基礎 系列 深刻 理解 枚舉 欄目 Java 简体版
原文   原文鏈接

本系列文章將整理到我在GitHub上的《Java面試指南》倉庫，更多精彩內容請到個人倉庫裏查看html

https://github.com/h2pl/Java-Tutorial前端

喜歡的話麻煩點下Star、Fork、Watch三連哈，感謝你的支持。java

文章首發於個人我的博客：git

www.how2playlife.com程序員

本文是微信公衆號【Java技術江湖】的《夯實Java基礎系列博文》其中一篇，本文部份內容來源於網絡，爲了把本文主題講得清晰透徹，也整合了不少我認爲不錯的技術博客內容，引用其中了一些比較好的博客文章，若有侵權，請聯繫做者。github

該系列博文會告訴你如何從入門到進階，一步步地學習Java基礎知識，並上手進行實戰，接着瞭解每一個Java知識點背後的實現原理，更完整地瞭解整個Java技術體系，造成本身的知識框架。爲了更好地總結和檢驗你的學習成果，本系列文章也會提供每一個知識點對應的面試題以及參考答案。面試

@[toc] 若是對本系列文章有什麼建議，或者是有什麼疑問的話，也能夠關注公衆號【Java技術江湖】聯繫做者，歡迎你參與本系列博文的創做和修訂。算法

<!-- more -->spring

枚舉（enum）類型是Java 5新增的特性，它是一種新的類型，容許用常量來表示特定的數據片段，並且所有都以類型安全的形式來表示。segmentfault

初探枚舉類

在程序設計中，有時會用到由若干個有限數據元素組成的集合，如一週內的星期一到星期日七個數據元素組成的集合，由三種顏色紅、黃、綠組成的集合，一個工做班組內十個職工組成的集合等等，程序中某個變量取值僅限於集合中的元素。此時，可將這些數據集合定義爲枚舉類型。

所以，枚舉類型是某類數據可能取值的集合，如一週內星期可能取值的集合爲： 　　{ Sun,Mon,Tue,Wed,Thu,Fri,Sat} 　　該集合可定義爲描述星期的枚舉類型，該枚舉類型共有七個元素，於是用枚舉類型定義的枚舉變量只能取集合中的某一元素值。因爲枚舉類型是導出數據類型，所以，必須先定義枚舉類型，而後再用枚舉類型定義枚舉型變量。 　

enum <枚舉類型名> 
　　{ <枚舉元素表> };
　　
　　其中：關鍵詞enum表示定義的是枚舉類型，枚舉類型名由標識符組成，而枚舉元素表由枚舉元素或枚舉常量組成。例如： 
　　
enum weekdays 
　　{ Sun,Mon,Tue,Wed,Thu,Fri,Sat };
　　定義了一個名爲 weekdays的枚舉類型，它包含七個元素：Sun、Mon、Tue、Wed、Thu、Fri、Sat。

在編譯器編譯程序時，給枚舉類型中的每個元素指定一個整型常量值(也稱爲序號值)。若枚舉類型定義中沒有指定元素的整型常量值，則整型常量值從0開始依次遞增，所以，weekdays枚舉類型的七個元素Sun、Mon、Tue、Wed、Thu、Fri、Sat對應的整型常量值分別爲0、一、二、三、四、五、6。 　　注意：在定義枚舉類型時，也可指定元素對應的整型常量值。

例如，描述邏輯值集合{TRUE、FALSE}的枚舉類型boolean可定義以下：
enum boolean 
　　{ TRUE=1 ,FALSE=0 };
該定義規定：TRUE的值爲1，而FALSE的值爲0。
　　
而描述顏色集合{red,blue,green,black,white,yellow}的枚舉類型colors可定義以下：
enum colors 
　　{red=5,blue=1,green,black,white,yellow};
　　該定義規定red爲5 ，blue爲1，其後元素值從2 開始遞增長1。green、black、white、yellow的值依次爲二、三、四、5。

　　此時，整數5將用於表示二種顏色red與yellow。一般兩個不一樣元素取相同的整數值是沒有意義的。枚舉類型的定義只是定義了一個新的數據類型，只有用枚舉類型定義枚舉變量才能使用這種數據類型。

枚舉類-語法

enum 與 class、interface 具備相同地位； 能夠繼承多個接口； 能夠擁有構造器、成員方法、成員變量； 1.2 枚舉類與普通類不一樣之處

默認繼承 java.lang.Enum 類，因此不能繼承其餘父類；其中 java.lang.Enum 類實現了 java.lang.Serializable 和 java.lang.Comparable 接口；

使用 enum 定義，默認使用 final 修飾，所以不能派生子類；

構造器默認使用 private 修飾，且只能使用 private 修飾；

枚舉類全部實例必須在第一行給出，默認添加 public static final 修飾，不然沒法產生實例；

枚舉類的具體使用

這部份內容參考http://www.javashuo.com/article/p-poapgxnl-ka.html

常量

public class 常量 {
}
enum Color {
    Red, Green, Blue, Yellow
}

switch

JDK1.6以前的switch語句只支持int,char,enum類型，使用枚舉，能讓咱們的代碼可讀性更強。

public static void showColor(Color color) {
        switch (color) {
            case Red:
                System.out.println(color);
                break;
            case Blue:
                System.out.println(color);
                break;
            case Yellow:
                System.out.println(color);
                break;
            case Green:
                System.out.println(color);
                break;
        }
    }

向枚舉中添加新方法

若是打算自定義本身的方法，那麼必須在enum實例序列的最後添加一個分號。並且 Java 要求必須先定義 enum 實例。

enum Color {
    //每一個顏色都是枚舉類的一個實例，而且構造方法要和枚舉類的格式相符合。
    //若是實例後面有其餘內容，實例序列結束時要加分號。
    Red("紅色", 1), Green("綠色", 2), Blue("藍色", 3), Yellow("黃色", 4);
    String name;
    int index;
    Color(String name, int index) {
        this.name = name;
        this.index = index;
    }
    public void showAllColors() {
        //values是Color實例的數組，在經過index和name能夠獲取對應的值。
        for (Color color : Color.values()) {
            System.out.println(color.index + ":" + color.name);
        }
    }
}

覆蓋枚舉的方法

全部枚舉類都繼承自Enum類，因此能夠重寫該類的方法 下面給出一個toString()方法覆蓋的例子。

@Override
public String toString() {
    return this.index + ":" + this.name;
}

實現接口

全部的枚舉都繼承自java.lang.Enum類。因爲Java 不支持多繼承，因此枚舉對象不能再繼承其餘類。

enum Color implements Print{
    @Override
    public void print() {
        System.out.println(this.name);
    }
}

使用接口組織枚舉

搞個實現接口，來組織枚舉，簡單講，就是分類吧。若是大量使用枚舉的話，這麼幹，在寫代碼的時候，就很方便調用啦。

public class 用接口組織枚舉 {
    public static void main(String[] args) {
        Food cf = chineseFood.dumpling;
        Food jf = Food.JapaneseFood.fishpiece;
        for (Food food : chineseFood.values()) {
            System.out.println(food);
        }
        for (Food food : Food.JapaneseFood.values()) {
            System.out.println(food);
        }
    }
}
interface Food {
    enum JapaneseFood implements Food {
        suse, fishpiece
    }
}
enum chineseFood implements Food {
    dumpling, tofu
}

枚舉類集合

java.util.EnumSet和java.util.EnumMap是兩個枚舉集合。EnumSet保證集合中的元素不重複；EnumMap中的 key是enum類型，而value則能夠是任意類型。

EnumSet在JDK中沒有找到實現類，這裏寫一個EnumMap的例子

public class 枚舉類集合 {
    public static void main(String[] args) {
        EnumMap<Color, String> map = new EnumMap<Color, String>(Color.class);
        map.put(Color.Blue, "Blue");
        map.put(Color.Yellow, "Yellow");
        map.put(Color.Red, "Red");
        System.out.println(map.get(Color.Red));
    }
}

使用枚舉類的注意事項

image

枚舉類型對象之間的值比較，是可使用==，直接來比較值，是否相等的，不是必須使用equals方法的喲。

由於枚舉類Enum已經重寫了equals方法

/**
 * Returns true if the specified object is equal to this
 * enum constant.
 *
 * @param other the object to be compared for equality with this object.
 * @return  true if the specified object is equal to this
 *          enum constant.
 */
public final boolean equals(Object other) {
    return this==other;
}

枚舉類的實現原理

這部分參考https://blog.csdn.net/mhmyqn/article/details/48087247

Java從JDK1.5開始支持枚舉，也就是說，Java一開始是不支持枚舉的，就像泛型同樣，都是JDK1.5才加入的新特性。一般一個特性若是在一開始沒有提供，在語言發展後期才添加，會遇到一個問題，就是向後兼容性的問題。

像Java在1.5中引入的不少特性，爲了向後兼容，編譯器會幫咱們寫的源代碼作不少事情，好比泛型爲何會擦除類型，爲何會生成橋接方法，foreach迭代，自動裝箱/拆箱等，這有個術語叫「語法糖」，而編譯器的特殊處理叫「解語法糖」。那麼像枚舉也是在JDK1.5中才引入的，又是怎麼實現的呢？

Java在1.5中添加了java.lang.Enum抽象類，它是全部枚舉類型基類。提供了一些基礎屬性和基礎方法。同時，對把枚舉用做Set和Map也提供了支持，即java.util.EnumSet和java.util.EnumMap。

接下來定義一個簡單的枚舉類

public enum Day {
    MONDAY {
        @Override
        void say() {
            System.out.println("MONDAY");
        }
    }
    , TUESDAY {
        @Override
        void say() {
            System.out.println("TUESDAY");
        }
    }, FRIDAY("work"){
        @Override
        void say() {
            System.out.println("FRIDAY");
        }
    }, SUNDAY("free"){
        @Override
        void say() {
            System.out.println("SUNDAY");
        }
    };
    String work;
    //沒有構造參數時，每一個實例能夠看作常量。
    //使用構造參數時，每一個實例都會變得不同，能夠看作不一樣的類型，因此編譯後會生成實例個數對應的class。
    private Day(String work) {
        this.work = work;
    }
    private Day() {

    }
    //枚舉實例必須實現枚舉類中的抽象方法
    abstract void say ();

}

反編譯結果

D:\MyTech\out\production\MyTech\com\javase\枚舉類>javap Day.class
Compiled from "Day.java"

public abstract class com.javase.枚舉類.Day extends java.lang.Enum<com.javase.枚舉類.Day> {
  public static final com.javase.枚舉類.Day MONDAY;
  public static final com.javase.枚舉類.Day TUESDAY;
  public static final com.javase.枚舉類.Day FRIDAY;
  public static final com.javase.枚舉類.Day SUNDAY;
  java.lang.String work;
  public static com.javase.枚舉類.Day[] values();
  public static com.javase.枚舉類.Day valueOf(java.lang.String);
  abstract void say();
  com.javase.枚舉類.Day(java.lang.String, int, com.javase.枚舉類.Day$1);
  com.javase.枚舉類.Day(java.lang.String, int, java.lang.String, com.javase.枚舉類.Day$1);
  static {};
}

能夠看到，一個枚舉在通過編譯器編譯事後，變成了一個抽象類，它繼承了java.lang.Enum；而枚舉中定義的枚舉常量，變成了相應的public static final屬性，並且其類型就抽象類的類型，名字就是枚舉常量的名字.

同時咱們能夠在Operator.class的相同路徑下看到四個內部類的.class文件com/mikan/Day$1.class、com/mikan/Day$2.class、com/mikan/Day$3.class、com/mikan/Day$4.class，也就是說這四個命名字段分別使用了內部類來實現的；同時添加了兩個方法values()和valueOf(String)；咱們定義的構造方法原本只有一個參數，但卻變成了三個參數；同時還生成了一個靜態代碼塊。這些具體的內容接下來仔細看看。

下面分析一下字節碼中的各部分，其中：

InnerClasses:
     static #23; //class com/javase/枚舉類/Day$4
     static #18; //class com/javase/枚舉類/Day$3
     static #14; //class com/javase/枚舉類/Day$2
     static #10; //class com/javase/枚舉類/Day$1

從中能夠看到它有4個內部類，這四個內部類的詳細信息後面會分析。

static {};
    descriptor: ()V
    flags: ACC_STATIC
    Code:
      stack=5, locals=0, args_size=0
         0: new           #10                 // class com/javase/枚舉類/Day$1
         3: dup
         4: ldc           #11                 // String MONDAY
         6: iconst_0
         7: invokespecial #12                 // Method com/javase/枚舉類/Day$1."<init>":(Ljava/lang/String;I)V
        10: putstatic     #13                 // Field MONDAY:Lcom/javase/枚舉類/Day;
        13: new           #14                 // class com/javase/枚舉類/Day$2
        16: dup
        17: ldc           #15                 // String TUESDAY
        19: iconst_1
        20: invokespecial #16                 // Method com/javase/枚舉類/Day$2."<init>":(Ljava/lang/String;I)V
        //後面相似，這裏省略
}

其實編譯器生成的這個靜態代碼塊作了以下工做：分別設置生成的四個公共靜態常量字段的值，同時編譯器還生成了一個靜態字段$VALUES，保存的是枚舉類型定義的全部枚舉常量 編譯器添加的values方法：

public static com.javase.Day[] values();  
  flags: ACC_PUBLIC, ACC_STATIC  
  Code:  
    stack=1, locals=0, args_size=0  
       0: getstatic     #2                  // Field $VALUES:[Lcom/javase/Day;  
       3: invokevirtual #3                  // Method "[Lcom/mikan/Day;".clone:()Ljava/lang/Object;  
       6: checkcast     #4                  // class "[Lcom/javase/Day;"  
       9: areturn  
這個方法是一個公共的靜態方法，因此咱們能夠直接調用該方法（Day.values()）,返回這個枚舉值的數組，另外，這個方法的實現是，克隆在靜態代碼塊中初始化的$VALUES字段的值，並把類型強轉成Day[]類型返回。

造方法爲何增長了兩個參數？

有一個問題，構造方法咱們明明只定義了一個參數，爲何生成的構造方法是三個參數呢？

從Enum類中咱們能夠看到，爲每一個枚舉都定義了兩個屬性，name和ordinal，name表示咱們定義的枚舉常量的名稱，如FRIDAY、TUESDAY，而ordinal是一個順序號，根據定義的順序分別賦予一個整形值，從0開始。在枚舉常量初始化時，會自動爲初始化這兩個字段，設置相應的值，因此纔在構造方法中添加了兩個參數。即：

另外三個枚舉常量生成的內部類基本上差很少，這裏就不重複說明了。

咱們能夠從Enum類的代碼中看到，定義的name和ordinal屬性都是final的，並且大部分方法也都是final的，特別是clone、readObject、writeObject這三個方法，這三個方法和枚舉經過靜態代碼塊來進行初始化一塊兒。

它保證了枚舉類型的不可變性，不能經過克隆，不能經過序列化和反序列化來複制枚舉，這能保證一個枚舉常量只是一個實例，便是單例的，因此在effective java中推薦使用枚舉來實現單例。

枚舉類實戰

實戰一無參

（1）定義一個無參枚舉類

enum SeasonType {
    SPRING, SUMMER, AUTUMN, WINTER
}

（2）實戰中的使用

// 根據實際狀況選擇下面的用法便可
SeasonType springType = SeasonType.SPRING;    // 輸出 SPRING 
String springString = SeasonType.SPRING.toString();    // 輸出 SPRING

實戰二有一參

（1）定義只有一個參數的枚舉類

enum SeasonType {
    // 經過構造函數傳遞參數並建立實例
    SPRING("spring"),
    SUMMER("summer"),
    AUTUMN("autumn"),
    WINTER("winter");

    // 定義實例對應的參數
    private String msg;

    // 必寫：經過此構造器給枚舉值建立實例
    SeasonType(String msg) {
        this.msg = msg;
    }

    // 經過此方法能夠獲取到對應實例的參數值
    public String getMsg() {
        return msg;
    }
}

（2）實戰中的使用

// 當咱們爲某個實例類賦值的時候可以使用以下方式
String msg = SeasonType.SPRING.getMsg();    // 輸出 spring

實戰三有兩參

（1）定義有兩個參數的枚舉類

public enum Season {
    // 經過構造函數傳遞參數並建立實例
    SPRING(1, "spring"),
    SUMMER(2, "summer"),
    AUTUMN(3, "autumn"),
    WINTER(4, "winter");

    // 定義實例對應的參數
    private Integer key;
    private String msg;

    // 必寫：經過此構造器給枚舉值建立實例
    Season(Integer key, String msg) {
        this.key = key;
        this.msg = msg;
    }

    // 不少狀況，咱們可能從前端拿到的值是枚舉類的 key ，而後就能夠經過如下靜態方法獲取到對應枚舉值
    public static Season valueofKey(Integer key) {
        for (Season season : Season.values()) {
            if (season.key.equals(key)) {
                return season;
            }
        }
        throw new IllegalArgumentException("No element matches " + key);
    }

    // 經過此方法能夠獲取到對應實例的 key 值
    public Integer getKey() {
        return key;
    }

    // 經過此方法能夠獲取到對應實例的 msg 值
    public String getMsg() {
        return msg;
    }
}

（2）實戰中的使用

// 輸出 key 爲 1 的枚舉值實例
Season season = Season.valueofKey(1);
// 輸出 SPRING 實例對應的 key
Integer key = Season.SPRING.getKey();
// 輸出 SPRING 實例對應的 msg
String msg = Season.SPRING.getMsg();

枚舉類總結

其實枚舉類懂了其概念後，枚舉就變得至關簡單了，隨手就能夠寫一個枚舉類出來。因此如上幾個實戰小例子必定要先搞清楚概念，而後在練習幾遍就 ok 了。

重要的概念，我在這裏在贅述一遍，幫助老鐵們快速掌握這塊知識，首先記住，枚舉類中的枚舉值能夠沒有參數，也能夠有多個參數，每個枚舉值都是一個實例；

而且還有一點很重要，就是若是枚舉值有 n 個參數，那麼構造函數中的參數值確定有 n 個，由於聲明的每個枚舉值都會調用構造函數去建立實例，因此參數必定是一一對應的；既然明白了這一點，那麼咱們只須要在枚舉類中把這 n 個參數定義爲 n 個成員變量，而後提供對應的 get() 方法，以後經過實例就能夠隨意的獲取實例中的任意參數值了。

若是想讓枚舉類更加的好用，就能夠模仿我在實戰三中的寫法那樣，經過某一個參數值，好比 key 參數值，就能獲取到其對應的枚舉值，而後想要什麼值，就 get 什麼值就行了。

枚舉 API

咱們使用 enum 定義的枚舉類都是繼承 java.lang.Enum 類的，那麼就會繼承其 API ，經常使用的 API 以下：

  • String name()

獲取枚舉名稱

  • int ordinal()

獲取枚舉的位置（下標，初始值爲 0 ）

  • valueof(String msg)

經過 msg 獲取其對應的枚舉類型。（好比實戰二中的枚舉類或其它枚舉類都行，只要使用得當均可以使用此方法）

  • values()

獲取枚舉類中的全部枚舉值（好比在實戰三中就使用到了）

總結

枚舉本質上是經過普通的類來實現的，只是編譯器爲咱們進行了處理。每一個枚舉類型都繼承自java.lang.Enum，並自動添加了values和valueOf方法。

而每一個枚舉常量是一個靜態常量字段，使用內部類實現，該內部類繼承了枚舉類。全部枚舉常量都經過靜態代碼塊來進行初始化，即在類加載期間就初始化。

另外經過把clone、readObject、writeObject這三個方法定義爲final的，同時實現是拋出相應的異常。這樣保證了每一個枚舉類型及枚舉常量都是不可變的。能夠利用枚舉的這兩個特性來實現線程安全的單例。

參考文章

https://blog.csdn.net/qq_34988624/article/details/86592229 https://www.meiwen.com.cn/subject/slhvhqtx.html https://blog.csdn.net/qq_34988624/article/details/86592229 http://www.javashuo.com/article/p-rwfrbdcr-hy.html https://my.oschina.net/wuxinshui/blog/1511484 https://blog.csdn.net/hukailee/article/details/81107412

微信公衆號

Java技術江湖

若是你們想要實時關注我更新的文章以及分享的乾貨的話，能夠關注個人公衆號【Java技術江湖】一位阿里 Java 工程師的技術小站，做者黃小斜，專一 Java 相關技術：SSM、SpringBoot、MySQL、分佈式、中間件、集羣、Linux、網絡、多線程，偶爾講點Docker、ELK，同時也分享技術乾貨和學習經驗，致力於Java全棧開發！

Java工程師必備學習資源: 一些Java工程師經常使用學習資源，關注公衆號後，後臺回覆關鍵字 「Java」 便可免費無套路獲取。

個人公衆號

我的公衆號：黃小斜

做者是 985 碩士，螞蟻金服 JAVA 工程師，專一於 JAVA 後端技術棧：SpringBoot、MySQL、分佈式、中間件、微服務，同時也懂點投資理財，偶爾講點算法和計算機理論基礎，堅持學習和寫做，相信終身學習的力量！

程序員3T技術學習資源： 一些程序員學習技術的資源大禮包，關注公衆號後，後臺回覆關鍵字 「資料」 便可免費無套路獲取。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程