java枚舉類型(enum)

原創 行者路上 2018-09-17 09:10

枚舉實現原理

package com.own.learn.jdk.enum1;



public enum Day {
    MONDAY("monday"), TUESDAY("TUESDAY"), WEDNESDAY("WEDNESDAY"),
    THURSDAY("THURSDAY"), FRIDAY("FRIDAY"), SATURDAY("SATURDAY"), SUNDAY("SUNDAY");

    private String name;

    Day(String name) {
        this.name = name;
    }
}

拿出來反編譯的代碼：

javap -c com/own/learn/jdk/enum1/Day.class 

public final class com.own.learn.jdk.enum1.Day extends java.lang.Enum<com.own.learn.jdk.enum1.Day> {
  public static final com.own.learn.jdk.enum1.Day MONDAY;

  public static final com.own.learn.jdk.enum1.Day TUESDAY;

  public static final com.own.learn.jdk.enum1.Day WEDNESDAY;

  public static final com.own.learn.jdk.enum1.Day THURSDAY;

  public static final com.own.learn.jdk.enum1.Day FRIDAY;

  public static final com.own.learn.jdk.enum1.Day SATURDAY;

  public static final com.own.learn.jdk.enum1.Day SUNDAY;

  public static com.own.learn.jdk.enum1.Day[] values();
    Code:
       0: getstatic     #1                  // Field $VALUES:[Lcom/own/learn/jdk/enum1/Day;
       3: invokevirtual #2                  // Method "[Lcom/own/learn/jdk/enum1/Day;".clone:()Ljava/lang/Object;
       6: checkcast     #3                  // class "[Lcom/own/learn/jdk/enum1/Day;"
       9: areturn

  public static com.own.learn.jdk.enum1.Day valueOf(java.lang.String);
    Code:
       0: ldc           #4                  // class com/own/learn/jdk/enum1/Day
       2: aload_0
       3: invokestatic  #5                  // Method java/lang/Enum.valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
       6: checkcast     #4                  // class com/own/learn/jdk/enum1/Day
       9: areturn

  static {};
    Code:
       0: new           #4                  // class com/own/learn/jdk/enum1/Day
       3: dup
       4: ldc           #8                  // String MONDAY
       6: iconst_0
       7: ldc           #9                  // String monday
       9: invokespecial #10                 // Method "<init>":(Ljava/lang/String;ILjava/lang/String;)V
      12: putstatic     #11                 // Field MONDAY:Lcom/own/learn/jdk/enum1/Day;
      15: new           #4                  // class com/own/learn/jdk/enum1/Day
      18: dup
      19: ldc           #12                 // String TUESDAY
      21: iconst_1
      22: ldc           #12                 // String TUESDAY
      24: invokespecial #10                 // Method "<init>":(Ljava/lang/String;ILjava/lang/String;)V
      27: putstatic     #13                 // Field TUESDAY:Lcom/own/learn/jdk/enum1/Day;
      30: new           #4                  // class com/own/learn/jdk/enum1/Day
      33: dup
      34: ldc           #14                 // String WEDNESDAY
      36: iconst_2
      37: ldc           #14                 // String WEDNESDAY
      39: invokespecial #10                 // Method "<init>":(Ljava/lang/String;ILjava/lang/String;)V
      42: putstatic     #15                 // Field WEDNESDAY:Lcom/own/learn/jdk/enum1/Day;
      45: new           #4                  // class com/own/learn/jdk/enum1/Day
      48: dup
      49: ldc           #16                 // String THURSDAY
      51: iconst_3
      52: ldc           #16                 // String THURSDAY
      54: invokespecial #10                 // Method "<init>":(Ljava/lang/String;ILjava/lang/String;)V
      57: putstatic     #17                 // Field THURSDAY:Lcom/own/learn/jdk/enum1/Day;
      60: new           #4                  // class com/own/learn/jdk/enum1/Day
      63: dup
      64: ldc           #18                 // String FRIDAY
      66: iconst_4
      67: ldc           #18                 // String FRIDAY
      69: invokespecial #10                 // Method "<init>":(Ljava/lang/String;ILjava/lang/String;)V
      72: putstatic     #19                 // Field FRIDAY:Lcom/own/learn/jdk/enum1/Day;
      75: new           #4                  // class com/own/learn/jdk/enum1/Day
      78: dup
      79: ldc           #20                 // String SATURDAY
      81: iconst_5
      82: ldc           #20                 // String SATURDAY
      84: invokespecial #10                 // Method "<init>":(Ljava/lang/String;ILjava/lang/String;)V
      87: putstatic     #21                 // Field SATURDAY:Lcom/own/learn/jdk/enum1/Day;
      90: new           #4                  // class com/own/learn/jdk/enum1/Day
      93: dup
      94: ldc           #22                 // String SUNDAY
      96: bipush        6
      98: ldc           #22                 // String SUNDAY
     100: invokespecial #10                 // Method "<init>":(Ljava/lang/String;ILjava/lang/String;)V
     103: putstatic     #23                 // Field SUNDAY:Lcom/own/learn/jdk/enum1/Day;
     106: bipush        7
     108: anewarray     #4                  // class com/own/learn/jdk/enum1/Day
     111: dup
     112: iconst_0
     113: getstatic     #11                 // Field MONDAY:Lcom/own/learn/jdk/enum1/Day;
     116: aastore
     117: dup
     118: iconst_1
     119: getstatic     #13                 // Field TUESDAY:Lcom/own/learn/jdk/enum1/Day;
     122: aastore
     123: dup
     124: iconst_2
     125: getstatic     #15                 // Field WEDNESDAY:Lcom/own/learn/jdk/enum1/Day;
     128: aastore
     129: dup
     130: iconst_3
     131: getstatic     #17                 // Field THURSDAY:Lcom/own/learn/jdk/enum1/Day;
     134: aastore
     135: dup
     136: iconst_4
     137: getstatic     #19                 // Field FRIDAY:Lcom/own/learn/jdk/enum1/Day;
     140: aastore
     141: dup
     142: iconst_5
     143: getstatic     #21                 // Field SATURDAY:Lcom/own/learn/jdk/enum1/Day;
     146: aastore
     147: dup
     148: bipush        6
     150: getstatic     #23                 // Field SUNDAY:Lcom/own/learn/jdk/enum1/Day;
     153: aastore
     154: putstatic     #1                  // Field $VALUES:[Lcom/own/learn/jdk/enum1/Day;
     157: return
}

轉換成代碼 大概是這樣的：

package com.own.learn.jdk.enum1;

public final class DayEnum extends Enum {
    public static DayEnum MONDAY;

    public static DayEnum TUESDAY;

    public static DayEnum WEDNESDAY;

    public static DayEnum THURSDAY;

    public static DayEnum FRIDAY;

    public static DayEnum SATURDAY;

    public static DayEnum SUNDAY;
    private static DayEnum $VALUES[];

    static {
        MONDAY = new DayEnum("MONDAY", 0);
        TUESDAY = new DayEnum("TUESDAY", 1);
        WEDNESDAY = new DayEnum("WEDNESDAY", 2);
        THURSDAY = new DayEnum("THURSDAY", 3);
        FRIDAY = new DayEnum("FRIDAY", 4);
        SATURDAY = new DayEnum("SATURDAY", 5);
        SUNDAY = new DayEnum("SUNDAY", 6);
        $VALUES = (new DayEnum[]{
                MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
        });
    }


    public DayEnum[] values() {
        return (DayEnum[]) $VALUES.clone();
    }

    public DayEnum valueOf(String name) {
        return (DayEnum) Enum.valueOf(com.own.learn.jdk.enum1.DayEnum.class, name);

    }

    protected DayEnum(String name, int ordinal) {
        super(name, ordinal);
    }

    @Override
    public String toString() {
        return super.toString();
    }
}

Enum類

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

    private final String name;


    public final String name() {
        return name;
    }


    private final int ordinal;


    public final int ordinal() {
        return ordinal;
    }


    protected Enum(String name, int ordinal) {
        this.name = name;
        this.ordinal = ordinal;
    }


    public String toString() {
        return name;
    }


    public final boolean equals(Object other) {
        return this == other;
    }


    public final int hashCode() {
        return super.hashCode();
    }


    protected final Object clone() throws CloneNotSupportedException {
        throw new CloneNotSupportedException();
    }


    public final int compareTo(E o) {
        Enum<?> other = (Enum<?>) o;
        Enum<E> self = this;
        if (self.getClass() != other.getClass() && // optimization
                self.getDeclaringClass() != other.getDeclaringClass())
            throw new ClassCastException();
        return self.ordinal - other.ordinal;
    }


    @SuppressWarnings("unchecked")
    public final Class<E> getDeclaringClass() {
        Class<?> clazz = getClass();
        Class<?> zuper = clazz.getSuperclass();
        return (zuper == Enum.class) ? (Class<E>) clazz : (Class<E>) zuper;
    }


    public static <T extends Enum<T>> T valueOf(Class<T> enumType,
                                                String name) {
        T result = enumType.enumConstantDirectory().get(name);
        if (result != null)
            return result;
        if (name == null)
            throw new NullPointerException("Name is null");
        throw new IllegalArgumentException(
                "No enum constant " + enumType.getCanonicalName() + "." + name);
    }

    /**
     * enum classes cannot have finalize methods.
     */
    protected final void finalize() {
    }


    private void readObject(ObjectInputStream in) throws IOException,
            ClassNotFoundException {
        throw new InvalidObjectException("can't deserialize enum");
    }

    private void readObjectNoData() throws ObjectStreamException {
        throw new InvalidObjectException("can't deserialize enum");
    }
}
  1. ordinal： 從0到Integer.Max_value的數字，只在EnumSet和EnumMap使用，默認是0.
  2. equals方法：`return this==other。枚舉是常量
  3. compareTo：默認比較的是：ordinal
  4. valueOf：enumType.enumConstantDirectory().get(name);
  Map<String, T> enumConstantDirectory() {
        if (enumConstantDirectory == null) {
            T[] universe = getEnumConstantsShared();
            if (universe == null)
                throw new IllegalArgumentException(
                    getName() + " is not an enum type");
            Map<String, T> m = new HashMap<>(2 * universe.length);
            for (T constant : universe)
                m.put(((Enum<?>)constant).name(), constant);
            enumConstantDirectory = m;
        }
        return enumConstantDirectory;
    }
 T[] getEnumConstantsShared() {
        if (enumConstants == null) {
            if (!isEnum()) return null;
            try {
                final Method values = getMethod("values");
                java.security.AccessController.doPrivileged(
                    new java.security.PrivilegedAction<Void>() {
                        public Void run() {
                                values.setAccessible(true);
                                return null;
                            }
                        });
                @SuppressWarnings("unchecked")
                T[] temporaryConstants = (T[])values.invoke(null);
                enumConstants = temporaryConstants;
            }
            // These can happen when users concoct enum-like classes
            // that don't comply with the enum spec.
            catch (InvocationTargetException | NoSuchMethodException |
                   IllegalAccessException ex) { return null; }
        }
        return enumConstants;
    }
    private volatile transient T[] enumConstants = null;

通過反射調用values方法得到枚舉的數組，然後轉成map

枚舉的進階用法

向enum類添加方法與自定義構造函數

public enum Day {
    MONDAY("monday"), TUESDAY("TUESDAY"), WEDNESDAY("WEDNESDAY"),
    THURSDAY("THURSDAY"), FRIDAY("FRIDAY"), SATURDAY("SATURDAY"), SUNDAY("SUNDAY");

    private String name;

    Day(String name) {
        this.name = name;
    }
}

enum類中定義抽象方法

package com.own.learn.jdk.enum1;

public enum  DayAbstractMethod {

    FOOD {
        @Override
        public void printName() {
            System.out.println(" name is " + name());
        }
    };

    public abstract void printName();


    public static void main(String[] args) {

        DayAbstractMethod.FOOD.printName();
    }
}

enum類與接口

package com.own.learn.jdk.enum1;

interface Start{
    void start();
}

interface End{
    void end();
}
public enum  EnumInterface implements Start, End{
    TEST1
    ;


    @Override
    public void start() {

    }

    @Override
    public void end() {

    }
}

與單例模式

public enum  EnumSingleton {

     private enum MyEnumSingleton{
        INSTANCE;
        private Resource resource;

        private MyEnumSingleton(){
            resource = new Resource();
        }

        public Resource getResource(){
            return resource;
        }
    }

    public static Resource getResource(){
        return MyEnumSingleton.INSTANCE.getResource();
    }

}

多線程環境下的安全性

這個特性上面已經介紹了，因爲INSTANCE最後會被編譯器處理成static final的，並且在static模塊中進行的初始化，因此它的實例化是在class被加載階段完成，是線程安全的。這個特性也決定了枚舉單例不是lazy的，如果你的單例初始化比較費時且大多數情況下只會被引用但是不會被真正調用的話，你需要使用lazy的單例模式（上面傳統單例的方法二實現）,而不要選擇枚舉單例。

不可被反射實例化

在Java中，不僅通過限制enum只能聲明private的構造方法來防止Enum被使用new進行實例化，而且還限制了使用反射的方法不能通過Constructor來newInstance一個枚舉實例。

序列化的唯一性

在序列化和反序列化的時候Enum的處理是和其他類不同的，在序列化的時候實際上只寫入了Enum的name成員，而沒有保存ordinal成員；在反序列化的時候從ObjectInputStream中讀取Enum的name成員，同時調用Enum的valueof方法傳入讀取的name得到對應的ordinal值。同時Enum是不支持自定義序列化和反序列化的，一些序列化和反序列化對應的函數例如readObject和writeObject及serialVersionUID等屬性在Enum的序列化過程中都是被忽略的。
Enum在序列化和反序列化上的特性保證了使用Enum來實現單例是經受得起序列化的攻擊的。

Java枚舉單例

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

Glass fish Chinese

http://groups.google.com/group/glassfish_china/web/glassfish?hl=zh-CN&hl=zh-CN

iteye_10196 2020-07-07 17:38:41

Java程序爲什麼需要調優（《大話Java性能優化》第一章第一節）

2011年1月，新加坡飛往杭州的航班。飛行時間很長，大約6個小時，坐在四周的人很快熟悉了，互相攀談起來。有一位小姑娘，16、7歲的摸樣，長得很漂亮，默默地坐在座位上，當有熱心的阿姨問起她的情況，她帶着疲倦自我介紹起來，“我在新加坡念初三，

zmycoco2 2020-07-06 06:45:55

[Core Java. Volume I. Fundamentals, 8th Edition]-3

利用StringBuilder加速碎片語句的拼接 need to build up strings from shorter strings，Every time you concatenate strings, a newString

十旋转45度 2020-07-02 20:10:50

AbstractQueuedSynchronizer：獨佔鎖

併發是java編程一個比較高級的一個點，自己也常常試用，但是對於併發怎麼實現了，確實不明白，打算認真學習下，從AbstractQueuedSynchronizer開始吧，自己水平有限，如果有不對的地方，麻煩指出來． Abstrac

行者路上 2020-06-30 12:05:15

java.lang.ref.Reference源代碼分析

自己想學習下java.lang.ref這個package下面的源碼，在網上找了找一些帖子看了看，感覺對自己的幫助很大，打算自己總結下java.lang.ref這個包，以及垃圾回收的機制，期待對自己有幫助． 一，引用實例有４個狀態，

行者路上 2020-06-30 12:05:15

說說，Java泛型

###特性 泛型只在編譯階段有效 public class GenericTest1 { public static void main(String[] args) { ArrayList<Strin

行者路上 2020-06-30 12:05:05

還怕面試官問你-volatile原理嗎？

###CPU的術語定義 volatile是輕量級的synchronized，比之執行成本更低,因爲它不會引起線程的上下文切換，它在多處理器開發中保證了共享變量的“可見性”，“可見性”的意思是當一個線程修改一個變量時，另外一個線程

行者路上 2020-06-30 12:05:05

JUnit小入門

  Junit小入門 1、 編寫功能代碼類： package leon.junit.test; public class AddOperation

水哥709 2020-06-29 00:18:48

Kafka的API-Java篇

上一篇文章已經將Kafka的服務配置分享了一遍，這篇主要是將java的API分享一波。 Kafka有四個核心API： Producer API ：允許應用程序發送數據流到kafka集羣中的topic。 Consumer API

我，大虫 2020-06-28 22:56:12

NIO系列(三) 零拷貝

1.介紹   在通過IO進行數據讀寫時(例如從文件讀取數據)，需要進行多次的數據拷貝，有些拷貝是通過DMA的方式進行的，有些拷貝是CPU 需要從來源把每一片段的資料複製到暫存器，然後把它們再次寫回到新的地方，這種方式效率較低。那所

Hubery_Yu_160521 2020-06-28 08:00:03

NIO系列(一) 核心概念介紹

1. 核心概念概述   近期又深入學習了一下NIO，預計寫幾篇NIO相關的博客作爲知識總結，博客內容主要爲筆者個人理解，如果錯誤望指正。   Java NIO是JDK1.4引入的新語法，與傳統IO不同，NIO是非阻塞且面向緩衝區(

Hubery_Yu_160521 2020-06-28 08:00:03

@V@ java代碼筆記2010-06-12：java控制檯輸入各類型類實現;以及判斷輸入字符串裏面是否有數字的兩種方法：方法1：轉換成字符數組；方法2：正則表達式。

轉自  ： http://jayxigua.iteye.com/blog/691025    package jay_x_20100612; import java.io.*; import java.util.regex.Patter

IMFuckingHigh 2020-06-28 04:29:02

利用Java5泛型實現泛型特性成分

本文參考節選自  機工社《數據結構與算法分析 Java語言描述》     一. 簡單的泛型類和接口   首先看以下代碼中的GenericMemoryCell泛型類： public class GenericMemoryCell<AnyTy

IMFuckingHigh 2020-06-28 04:28:51

Java導出Oracle數據庫數據

最近項目中要數據備份和數據恢復。利用的數據庫是Oracle。如果使用命令行，在命令行中可以直接使用Oracle的exp和imp命令。比如：windows中，點擊開始-》運行，輸入cmd，打開命令行窗口。導出數據庫和數據。輸入exp 用戶名

pttaag 2020-06-24 04:33:57

內部類：Core Java 6.4

如果一個類定義在另一個類的內部，這個類就是內部類。 爲什麼要用內部類，什麼場景下需要用內部類 根據面向對象設計原則，需要定義一個新的類，並對相關操作和屬性進行封裝。 新類僅同另一個類有密切依賴關係或者邏輯關係，其它類基本不

李思苇 2020-06-23 05:51:40