2. 程式人生 > >Java基礎15：深入剖析Java枚舉類

Java基礎15：深入剖析Java枚舉類

阿新 • • 發佈：2019-02-08
eth invoke out mode 分類 from 常量 更強 特殊

Java基礎15：深入剖析Java枚舉類

枚舉（enum）類型是Java 5新增的特性，它是一種新的類型，允許用常量來表示特定的數據片斷，而且全部都以類型安全的形式來表示。

初探枚舉類

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

因此，枚舉類型是某類數據可能取值的集合，如一周內星期可能取值的集合為： 　　{ 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、1、2、3、4、5、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的值依次為2、3、4、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 修飾，否則無法產生實例；

枚舉類的具體使用

這部分內容參考https://blog.csdn.net/qq_27093465/article/details/52180865

常量

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

使用枚舉類的註意事項

技術分享圖片

枚舉類型對象之間的值比較，是可以使用==，直接來比較值，是否相等的，不是必須使用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中推薦使用枚舉來實現單例。

總結

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

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

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

Java基礎15：深入剖析Java枚舉類

相關推薦

Java基礎15：深入剖析Java枚舉類

eth invoke out mode 分類 from 常量 更強 特殊 Java基礎15：深入剖析Java枚舉類 枚舉（enum）類型是Java 5新增的特性，它是一種新的類型，允許用常量來表示特定的數據片斷，而且全部都以類型安全的形式來表示。 初探枚舉類 在程序設計中

Java基礎3：深入理解String及包裝類

運行 例子 integer image soft 浪費 十分 應該 pub Java基礎3：深入理解String及包裝類 String的連接 @Testpublic void contact () { //1連接方式 String s1 = "a"; St

【轉】Java併發程式設計：深入剖析ThreadLocal

　想必很多朋友對ThreadLocal並不陌生，今天我們就來一起探討下ThreadLocal的使用方法和實現原理。首先，本文先談一下對ThreadLocal的理解，然後根據ThreadLocal類的原始碼分析了其實現原理和使用需要注意的地方，最後給出了兩個應用場景。 　　以

Java基礎8：深入理解內部類

這位大俠，這是我的公眾號：程式設計師江湖。 分享程式設計師面試與技術的那些事。 乾貨滿滿，關注就送。 本文主要介紹了Java內部類的基本原理，使用方法和各種細節。 有關內部類實現回撥，事件驅動和委託機制的文章將在後面釋出。 具體程式碼在我的GitHu

java基礎4：深入理解final關鍵字

數據類型 nal contain print ces 修飾 實例 被子 一個 java基礎4：深入理解final關鍵字 final關鍵字可以修飾類、方法和引用。 修飾類，該類不能被繼承。並且這個類的對象在堆中分配內存後地址不可變。 修飾方法，方法不能被子類重寫。 修飾引用

Java併發程式設計：深入剖析ThreadLocal

　前陣子在專案中剛處理過一個生產問題，問題現象是兩次請求我們系統的服務，第二次請求能取到第一次請求報文的部分內容，並且出現這種情況時，處理交易的兩個執行緒號是相同的。最終跟蹤程式碼，發現了使用執行緒池時，使用了ThreadLocal物件，在每次請求過來時，Thr

基礎篇：深入解析JAVA註解機制

[TOC](目錄標題) # java實現註解的底層原理和概念 - java註解是JDK1.5引入的一種註釋機制，java語言的類、方法、變數、引數和包都可以被註解標註。和Javadoc不同，java註解可以通過反射獲取標註內容 - 在編譯器生成.class檔案時，註解可以被嵌入位元組碼中，而jvm也可以保

Java基礎15-final、static關鍵字和Object類

不同 擁有 bsp 指數 col main hashcode 技術分享 fin 一、final關鍵字 1.什麽是final關鍵字 繼承的出現提高了代碼的復用性，並方便開發。但隨之也有問題，有些類在描述完之後，不想被繼承，或者有些類中的部分方法功能是固定的，不想讓子類重寫。可

Java基礎10：全面解讀Java異常

pre ces new t runt final ray 子類 尋找 原因 Java基礎10：全面解讀Java異常 為什麽要使用異常 首先我們可以明確一點就是異常的處理機制可以確保我們程序的健壯性，提高系統可用率。雖然我們不是特別喜歡看到它，但是我們不能不承認它的地位

Java並發編程：深入剖析ThreadLocal

轉載 就是 場景 null return 也有 既然 多個 vat 想必很多朋友對ThreadLocal並不陌生，今天我們就來一起探討下ThreadLocal的使用方法和實現原理。首先，本文先談一下對ThreadLocal的理解，然後根據ThreadLocal類的源碼分析了

java基礎學習總結（十二）：深入理解java內部類

內部類 內部類也是語法糖，是因為它僅僅是一個編譯時的概念，outer.java裡面定義了一個內部類inner，一旦編譯成功，就會生成兩個完全不同的.class檔案了，分別是outer.class和outer$inner.class。所以內部類的名字完全可以和它的外部類名字相同。 內部類分為四

java基礎學習總結（九）：深入理解Java泛型

一、什麼是泛型         “泛型” 意味著編寫的程式碼可以被不同型別的物件所重用。泛型的提出是為了編寫重用性更好的程式碼。泛型的本質是引數化型別，也就是說所操作的資料型別被指定為一個引數。 比如常見的集合類 LinkedList: publi

Java基礎：深入理解java異常處理機制的原理和開發應用【轉載】

Java異常處理機制在日常開發中應用頻繁，本篇文章主要在基礎的使用方法上，更進一步的，如何更加合理的使用異常機制，希望可以對各位朋友能有所幫助。 　　Java異常處理機制其最主要的幾個關鍵字：try、catch、finally、throw、throws，以及各種各樣

Java基礎：深入理解Java的介面和抽象類

     對於面向物件程式設計來說，抽象是它的一大特徵之一。在Java中，可以通過兩種形式來體現OOP的抽象：介面和抽象類。這兩者有太多相似的地方，又有太多不同的地方。很多人在初學的時候會以為它們可以隨意互換使用，但是實際則不然。今天我們就一起來學習一下Java中的介面和

框架基礎：深入理解Java註解型別(@Annotation)

註解的概念 註解的官方定義 首先看看官方對註解的描述： An annotation is a form of metadata, that can be added to Java source code. Classes, methods, variables, parameters and pa

夯實Java基礎系列10：深入理解Java中的異常體系

目錄 為什麼要使用異常 異常基本定義 異常體系 初識異常 異常和錯誤 異常的處理方式 "不負責任"的throws 糾結的finally throw : JRE也使用的關鍵字 異常呼叫鏈 自定義異常 異常的注意事項 當finally遇上return JAVA異常常見面試題 參考文章 微信公眾號 Java技術

夯實Java基礎系列11：深入理解Java中的回撥機制

目錄 模組間的呼叫 多執行緒中的“回撥” Java回撥機制實戰 例項一 ： 同步呼叫 例項二：由淺入深 例項三：Tom做題 參考文章

夯實Java基礎系列12：深入理解Java中的反射機制

本系列文章將整理到我在GitHub上的《Java面試指南》倉庫，更多精彩內容請到我的倉庫裡檢視 https://github.com/h2pl/Java-Tutorial 喜歡的話麻煩點下Star哈 文章首發於我的個人部落格： www.how2playlife.com 列舉（enum）型別是Java

Java基礎系列6：深入理解Java異常體系

該系列博文會告訴你如何從入門到進階，一步步地學習Java基礎知識，並上手進行實戰，接著瞭解每個Java知識點背後的實現原理，更完整地瞭解整個Java技術體系，形成自己的知識框架。   前言： Java的基本理念是“結構不佳的程式碼不能執行”。 “異常”這個詞有“我對此感到意外”的意思。問題出現了，你

Java基礎面試：集合、內部類、線程

public 死鎖 exceptio read 多線程 三種 xtend arraylist 表示 package test; import java.util.Hashtable; import java.util.Map; public class test {