Java枚舉深度解讀,看這篇就夠了

2021-02-18 java1234

點擊上方藍色字體，選擇「標星公眾號」

優質文章，第一時間送達

  作者 |  濤GuoGuo的跟屁蟲丶博Ke 

來源 |  urlify.cn/aaamQf

66套java從入門到精通實戰課程分享

Java枚舉

1、枚舉類概念的理解與定義

通俗的說：一個類被設計為包含固定實例數量的特殊類，我們給他的定義是枚舉類。

注意：
1.枚舉類不能被 new 出來，枚舉類因為默認的類修飾符為 final 所以也不能被派生（繼承），同理枚舉類也不能為當作實現。
2.枚舉類自身可以實現接口，既可以進行統一實現重寫接口抽象方法，也可以按照枚舉類型單個實現重寫。

2、枚舉類的定義

關於枚舉類的定義，這塊主要想和大家分享兩種方式

jdk 5.0之前，自定義枚舉類方式

jdk 5.0之後，Enum關鍵字方式定義


3、實踐（一）、準備工作

我們新建一個 Java Project ，並創建一個包，以及一個測試類

（二）、自定義枚舉的三種方式(jdk 5.0 之前)1. 定義一個抽象類，在抽象類中定義常量進行維護，我們接下來以 Java 類庫中的 Calendar 類示例來進行說明

新建一個類 EnumDemo01.java 代碼如下：

package org.taoguoguo;
import java.util.Calendar;

/**
 * @author taoGG
 * @description jdk 5.0 之前 抽象類枚舉方案Demo
 * @create 2020-09-13 14:20
 */
public class EnumDemo01 {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.get(1));
    }
}
Console 結果輸出：
2020
Process finished with exit code 0
如果熟悉 Calendar API 的小夥伴 應該馬上能反應過來，這個是獲取當前的年份，類似的值還有
3 - 一年中的第幾個星期
4 - 一年中的第幾個月
5 - 當前的日期 
.
但是這麼多值，我們怎麼能記得住呢？萬一我輸入錯誤，隨便取了一個範圍怎麼辦？
沒錯，這是 jdk 5.0之前的痛點，為了解決實例數量固定，便於維護這些問題，在jdk 5.0之後更新Enum枚舉類解決了這個問題。那在jdk 5.0之前官方是怎麼做的呢？難道需要我們一個個去記住 Calendar 的數字？
實際上官方本身，採用的就是我們現在說的第一種方式，在抽象類中定義常量進行維護
現在我們將代碼做些修改：
package org.taoguoguo;
import java.util.Calendar;

/**
 * @author taoGG
 * @description jdk 5.0 之前 抽象類枚舉方案Demo
 * @create 2020-09-13 14:20
 */
public class EnumDemo01 {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.get(Calendar.YEAR));
    }
}
我們運行進行輸出：
2020
Process finished with exit code 0
結果與之前一致，這時我們就清楚，在開發過程中作為開發者我們肯定願意使用 Calendar.YEAR 這種寫法，一來方便記憶，二來可讀性高。那麼官方的做法時怎樣的呢？我們點進去源碼看一下
首先 Calendar 本身是一個抽象類，實現了序列化、克隆、以及比較排序接口，這邊和我們枚舉沒有太大關係，我們繼續往下看
在抽象類中，定義了很多個靜態常量進行維護，而當我們需要使用時，直接調用，這樣就比我們寫一個個的具體值要方便和易用了。
2. 定義一個接口，在接口中定義常量維護枚舉值
我們新建一個interface CustomerInf.java
package org.taoguoguo;

/**
 * @author taoGG
 * @description 接口常量維護枚舉值
 * @create 2020-09-13 15:47
 */
public interface CustomerInf {
   int RED = 1;
   int GREEN = 2;
   int BLUE = 3;
}

在 EnumTest 進行測試
package org.taoguoguo;

/**
 * @author taoGG
 * @description Java枚舉測試類
 * @create 2020-09-13 14:54
 *
 */
public class EnumTest {
    public static void main(String[] args) {
        System.out.println(CustomerInf.RED);
    }
}

測試結果：
1
Process finished with exit code 0
這種做法我們達到了和在抽象類中維護常量相同的目的。上面這兩種做法都非常的簡單易用，但也有弊端。比如我們只知道一個狀態值，當我們要獲取狀態的屬性或者相關的內容時，我們該怎麼做呢？
下面我們使用第三種方式，自定義枚舉類，這種基本上達到和 Enum 關鍵字相同的作用，但有一點不足就是會較為複雜
3.自定義枚舉類，通過為類私有化構造器和固定實例對象進行枚舉維護
新建一個class SeasonEnum.java，代碼如下：
package org.taoguoguo;

/**
 * @author taoGG
 * @description
 * @create 2020-09-13 15:58
 */
public class SeasonEnum {
    //1.聲明枚舉對象的屬性
    private final String seasonName;
    private final int code;

    //2.私有化類的構造器
    private SeasonEnum(String seasonName,int code){
        this.seasonName = seasonName;
        this.code = code;
    }

    //3.提供當前枚舉類的多個對象 public static final
    public static final SeasonEnum SPRING = new SeasonEnum("春天",100);
    public static final SeasonEnum SUMMER = new SeasonEnum("夏天",200);
    public static final SeasonEnum AUTUMN = new SeasonEnum("秋天",300);
    public static final SeasonEnum WINTER = new SeasonEnum("冬天",400);

    //4.為類提供獲取屬性的方法
    public String getSeasonName() {
        return seasonName;
    }
    public int getCode() {
        return code;
    }
    //5.重寫toString方法
    @Override
    public String toString() {
        return "SeasonEnum{" +
                "seasonName='" + seasonName + '\'' +
                ", code=" + code +
                '}';
    }
}
新建一個class SeasonEnumTest 進行測試，當我們通過自定義枚舉類引用實例對象時，如下圖可以看到，我們已經可以獲取到我們的枚舉對象了。

獲取到枚舉對象，我們當然也可以獲取到對應的屬性及方法，這種可用性就提高了很多，我們在開發程序進行判斷，可以根據各種枚舉值的指定屬性來進行，提高了代碼的可維護性。

SeasonEnumTest 測試代碼
package org.taoguoguo;

/**
 * @author taoGG
 * @description
 * @create 2020-09-13 16:04
 */
public class SeasonEnumTest {
    public static void main(String[] args) {
        SeasonEnum spring = SeasonEnum.SPRING;
        System.out.println("自定義枚舉類對象：" + spring);
        System.out.println("自定義枚舉類屬性：" + spring.getSeasonName());
        System.out.println("自定義枚舉類屬性：" + spring.getCode());
    }
}


根據我們上面的自定義枚舉類方式，我們基本已經實現了枚舉的功能了，但是就像上面說到的，如果開發中枚舉類型較多，開發多個這樣的自定義枚舉類會非常的耗時，所以 jdk 5.0 之後，推出了 Enum 關鍵字定義枚舉類
（三）Enum 關鍵字定義枚舉類(jdk 5.0之後)
enum 全稱為 enumeration，是jdk 5.0 中引入的新特性，在Java 中被 enum 關鍵字修飾的類型就是枚舉類型
我們通過代碼來示例來講解和理解 enum 的用法，還是用我們剛剛自定以枚舉類的例子，看看使用enum如何來寫
新建一個Java class ，Kind 類型選擇 enum 如圖：

枚舉類創建注意：
枚舉實例必須在 enum關鍵字聲明的類中顯式的指定(首行開始的以第一個分號結束)
枚舉不允許使用new,clone,反射,序列化手動創建枚舉實例
package org.taoguoguo;

/**
 * @author taoGG
 * @description
 * @create 2020-09-13 16:23
 */
public enum Season {
    SPRING("春天",100),
    SUMMER("夏天",200),
    AUTUMN("秋天",300),
    WINTER("冬天",400);

    private final String seasonName;
    private final int code;

    Season(String seasonName, int code){
        this.seasonName = seasonName;
        this.code = code;
    }

    public String getSeasonName() {
        return seasonName;
    }
    public int getCode() {
        return code;
    }
}
使用 SeasonTest 測試類進行測試：
package org.taoguoguo;

/**
 * @author taoGG
 * @description
 * @create 2020-09-13 16:27
 */
public class SeasonTest {
    public static void main(String[] args) {
        Season spring = Season.SPRING;
        System.out.println(spring);
    }
}


輸出結果：
SPRING
Process finished with exit code 0
注意，在enmu 枚舉類中如果沒有重寫 toString方法，會默認使用Enum類本身提供的 toString 方法，返回枚舉類名稱，因為定義的枚舉類默認隱式繼承於java.lang.Enum
1.枚舉類主要方法介紹
values()  ：該方法可以返回當前枚舉類型的對象數組，可以很方便的遍歷所有枚舉值。一般我們可以根據枚舉類的相關屬性通過此方法遍歷獲取對應的枚舉對象及枚舉值
valueOf(String str) : 根據枚舉類名稱獲取枚舉類對象
toString(): 默認使用 java.lang.Enum的 toString方法，返回當前對象常量的名稱，枚舉類推薦重寫返回自定義友好描述
name(): 返回當前枚舉對象名稱，和toString作用上類似，當時toString支持重寫，name方法是不能重寫的，在本質上 toString 也是調用的 name方法，枚舉定義 name 方法就是為了返回枚舉對象名稱，而 toString 應該根據需要進行重寫
ordinal(): 返回當前枚舉對象的序號， 實現了 Comparable 接口，表明它是支持排序的 可以通過 Collections.sort 進行自動排序比較此枚舉與指定對象的順序
compareTo(): 基於ordinal進行序號大小比較
方式演示代碼，小夥伴們可以自行運行輸出一下，看看各個方法的作用，熟悉一下相關的方法api
package org.taoguoguo;

/**
 * @author taoGG
 * @description
 * @create 2020-09-13 16:27
 */
public class SeasonTest {
    public static void main(String[] args) {
        System.out.println("========values()方法=======");
        for (Season season : Season.values()) {
            System.out.println(season);
        }
        System.out.println("===========================");
 
        System.out.println("========valueOf方法========");
        Season spring = Season.valueOf("SPRING");
        System.out.println(spring);
        System.out.println("===========================");

        System.out.println("========toString方法========");
        System.out.println(spring.toString());
        System.out.println("===========================");

        System.out.println("========name方法========");
        System.out.println(spring.name());
        System.out.println("===========================");

        System.out.println("========ordinal方法========");
        System.out.println(spring.ordinal());
        System.out.println("===========================");

        System.out.println("========compareTo方法========");
        System.out.println(spring.compareTo(Season.WINTER));
        System.out.println("===========================");
    }
}
2.枚舉類對接口的實現方式準備工作
新建一個EnumInf 接口，定義一個抽象方法
package org.taoguoguo;

/**
 * @author taoGG
 * @description
 * @create 2020-09-13 17:25
 */
public interface EnumInf {
    void show();
}

1.實現接口，在enum中統一實現抽象方法
新建一個EnumInf 接口，定義抽象方法 show()
package org.taoguoguo;

/**
 * @author taoGG
 * @description
 * @create 2020-09-13 17:25
 */
public interface EnumInf {
    void show();
}


新建一個OrderStatus 枚舉類 實現 EnumInf 接口
package org.taoguoguo;

/**
 * @author taoGG
 * @description
 * @create 2020-09-13 17:27
 */
public enum OrderStatus implements EnumInf{

    SUCCESS(200,"交易成功"),
    Fail(500,"交易失敗");

    private final int code;
    private final String desc;

    OrderStatus(int code, String desc){
        this.code = code;
        this.desc = desc;
    }

    public int getCode() {
        return code;
    }
    public String getDesc() {
        return desc;
    }

    /**
     * 第一種方式，枚舉統一重寫接口抽象方法
     */
    @Override
    public void show() {
        System.out.println("訂單枚舉對象");
    }
}

進行測試
package org.taoguoguo;

/**
 * @author taoGG
 * @description
 * @create 2020-09-13 17:32
 */
public class OrderStatusTest {
    public static void main(String[] args) {
        OrderStatus success = OrderStatus.SUCCESS;
        success.show();
    }
}


輸出結果
訂單枚舉對象

Process finished with exit code 0
跟我們常用類實現沒有什麼區別，枚舉也是可以統一實現的，那如果想針對不同的枚舉對象進行不同狀態的實現怎麼辦呢？比如我們的OA系統、或者電商系統中，根據不同狀態 我們需要回寫對應的數據，下面我們就來看看如何實現。
2.枚舉對象分別實現接口中的抽象方法
案例跟接口統一實現一致，我們這邊修改一下OrderStatus 枚舉類，代碼如下
package org.taoguoguo;

/**
 * @author taoGG
 * @description
 * @create 2020-09-13 17:27
 */
public enum OrderStatus implements EnumInf{

    SUCCESS(200,"交易成功") {
        @Override
        public void show() {
            System.out.println("回寫交易成功狀態");
        }
    },
    Fail(500,"交易失敗") {
        @Override
        public void show() {
            System.out.println("回寫交易失敗狀態");
        }
    };

    private final int code;
    private final String desc;

    OrderStatus(int code, String desc){
        this.code = code;
        this.desc = desc;
    }

    public int getCode() {
        return code;
    }
    public String getDesc() {
        return desc;
    }

}
我們再修改下測試類代碼：
package org.taoguoguo;

/**
 * @author taoGG
 * @description
 * @create 2020-09-13 17:32
 */
public class OrderStatusTest {
    public static void main(String[] args) {
        OrderStatus success = OrderStatus.SUCCESS;
        success.show();
        OrderStatus fail = OrderStatus.Fail;
        fail.show();
    }
}
輸出結果
回寫交易成功狀態
回寫交易失敗狀態

Process finished with exit code 0
通過這種方式就可以輕而易舉地定義每個枚舉實例不同的行為方式，也達到了我們預期的效果，其實在開發過程中根據枚舉的設計和設計模式的鋪墊可以極大的簡化我們的業務代碼。
3.Enum枚舉類的工具類及應用場景1.EnumSet 和 EnumMap
Java 中提供了兩個方便操作enum的工具類——EnumSet 和 EnumMap。
EnumSet 是枚舉類型的高性能 Set 實現。它要求放入它的枚舉常量必須屬於同一枚舉類型。
// EnumSet的使用
System.out.println("EnumSet展示");
EnumSet<OrderStatus> errSet = EnumSet.allOf(OrderStatus.class);
for (OrderStatus e : errSet) {
    System.out.println(e.name() + " : " + e.ordinal());
}
EnumMap 是專門為枚舉類型量身定做的 Map 實現。雖然使用其它的 Map 實現（如HashMap）也能完成枚舉類型實例到值得映射，但是使用 EnumMap 會更加高效：它只能接收同一枚舉類型的實例作為鍵值，並且由於枚舉類型實例的數量相對固定並且有限，所以 EnumMap 使用數組來存放與枚舉類型對應的值。(計算機處理連續的資源使用局部內存效率更高)這使得 EnumMap 的效率非常高。
// 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());
}
2.枚舉類與 Switch 的配合使用
關於枚舉與switch是個比較簡單的話題，使用switch進行條件判斷時，條件參數一般只能是整型，字符型。而枚舉型確實也被switch所支持，在java 1.7後switch也對字符串進行了支持。
實踐
新建一個 BizEnum 的java class，代碼如下
package org.taoguoguo;

/**
 * @author taoGG
 * @description 企業類型枚舉
 * @create 2020-09-13 21:24
 */
public enum BizEnum {

    COUNTRIES(101,"國有企業"),

    PRIVETE(102,"私營企業"),

    SOHO(103,"個體單位");

    private final int code;
    private final String desc;

    BizEnum(int code, String desc){
        this.code = code;
        this.desc = desc;
    }

    public int getCode() {
        return code;
    }
    public String getDesc() {
        return desc;
    }

    //根據編碼獲取當前枚舉對象的方法
    public static BizEnum getBizTypeByCode(int code){
        for (BizEnum bizEnum : BizEnum.values()) {
            if(code == bizEnum.getCode()){
                return bizEnum;
            }
        }
        return null;
    }
}
結合Switch進行測試
package org.taoguoguo;

/**
 * @author taoGG
 * @description
 * @create 2020-09-13 21:31
 */
public class BizTest {
    public static void main(String[] args) {
        BizEnum bizType = BizEnum.getBizTypeByCode(101);
        switch (bizType){
            case COUNTRIES:
                System.out.println("國有企業");
                break;
            case PRIVETE:
                System.out.println("私營企業");
                break;
            case SOHO:
                System.out.println("個體單位");
                break;
            default:
                System.out.println("創業中");
        }
    }
}
輸出結果：
國有企業

Process finished with exit code 0

總結
jdk 5.0之前我們可以自定義枚舉類，jdk 5.0之後使用enum關鍵字定義枚舉類，枚舉類默認繼承自java.lang.Enum，使用枚舉類將常量組織起來，便於統一管理。例如錯誤碼、狀態機等場景中，較為合適使用枚舉類。
枚舉類常用方法介紹及枚舉類實現抽象類、接口等抽象方法的兩種方式。
枚舉常用的工具類及與switch使用的場景。
粉絲福利：108本java從入門到大神精選電子書領取
👇👇👇
感謝點讚支持下哈 

相關焦點

  • 程序進階:一起來用用Java枚舉
    比如當我們需要對一些類的屬性需要作出限制時，這些方法就不太適用，為了解決這種問題，在JDK1.5之後引入了枚舉類型，這篇文章中老梁就和大家一起好好聊聊枚舉。枚舉類型亦不例外，在下面的例子中老梁使用enum.values()的方式，通過foreach直接將枚舉中的內容全部輸出，具體的代碼例子可以看下圖：枚舉不但可以使用foreach進行遍歷，還可以使用switch對枚舉中的內容進行判斷。
  • 【枚舉】用好 Java 中的枚舉,真的沒有那麼簡單!
    「最近重看 Java 枚舉，看到這篇覺得還不錯的文章，於是簡單翻譯和完善了一些內容，分享給大家，希望你們也能有所收穫。另外，不要忘了文末還有補充哦！ps: 這裡發一篇枚舉的文章，也是因為後面要發一篇非常實用的關於 SpringBoot 全局異常處理的比較好的實踐裡面就用到了枚舉。
  • Java面向對象之枚舉——enum
    ，WEDNESDAY，THURSDAY ，FRIDAY，SATURDAY，SUNDAY；}在開發中自定義的枚舉類，在底層都是直接繼承於java.lang.Enum類的，Enum類是所有枚舉的父類。看下圖會有一個更直觀的感受：
  • Java枚舉(Enum)類型原理探求
    Java中的枚舉枚舉前時代在Java語言中， 枚舉類型從JDK1.5才開始提供。在這之前使用接口靜態常量來實現相關功能（也可以是類靜態常量），以季節為例：在不使用枚舉類之前，一般使用接口靜態常量實現。：java.lang.Enum。
  • Java 枚舉類型使用,枚舉集合介紹
    枚舉類型從前面的數據類型章節可知 Java 中並沒有枚舉類型，但通過 Java API 中的 java.lang.Enum 枚舉類我們可以定義枚舉類型數據，本質上還是一個類類型。為什麼要定義枚舉類型？有時後變量只會取幾個確定值中的一個，這時枚舉類型就很方便了，如定義一周的星期幾：1.枚舉類型的定義通過關鍵字 enum 定義枚舉類型數據，數據值一般採用大寫。定義位置可以放在類中，類的外部，或者另外的文件中定義。
  • Java枚舉使用詳解
    在java中如何更好的使用這些「數據集」呢？因此枚舉便派上了用場，以下代碼詳細介紹了枚舉的用法。package com.ljq.test; /** * 枚舉用法詳解 * * @author jiqinlin * */ public class TestEnum { /** * 普通枚舉 * * @author jiqinlin * */ public enum ColorEnum { red, green, yellow, blue; } /** * 枚舉像普通的類一樣可以添加屬性和方法
  • java enum(枚舉)使用詳解 + 總結
    enum 關鍵字，隱含了所創建的類型都是 java.lang.Enum 類的子類（java.lang.Enum 是一個抽象類）。這段代碼實際上調用了7次 Enum(String name, int ordinal)：new Enum<EnumTest>("MON",0); new Enum<EnumTest>("TUE",1); new Enum<EnumTest>("WED",2); ... ...
  • Java枚舉用法詳解
    枚舉的典型應用場景：錯誤碼、狀態機等。枚舉類型的本質儘管 enum 看起來像是一種新的數據類型，事實上，enum是一種受限制的類，並且具有自己的方法。創建enum時，編譯器會為你生成一個相關的類，這個類繼承自 java.lang.Enum。
  • 每日一課 | Java –比較枚舉值
    Java枚舉示例Language.javapackage com.mkyong.java public enum Language {    JAVA,    PYTHON,    NODE,    NET,    RUBY}2.與==比較將枚舉值與==運算符進行比較的示例。
  • 尚學堂知識整理:java 枚舉值
    枚舉類型定義了兩件事：枚舉常量名稱常量的順序以下代碼聲明了一個名為Level的公共枚舉類型，它具有四個枚舉常量：LOW，MEDIUM，HIGH 和 URGENT。Level枚舉類型定義了四個枚舉常量。級別枚舉類型的變量只能是以下四個值之一 - LOW，MEDIUM，HIGH 和 URGENT 或 null。可以通過使用枚舉類型名稱作為限定符和點符號來引用枚舉常量。以下代碼將Level枚舉類型常量的值分配給一些局部變量：但是不能實例化枚舉類型。
  • Java枚舉原來還能這麼用
    前言相信不少java開發者寫過狀態變更的業務，比如訂單流程、請假流程等等。一般會搞一個狀態標識來標識生命周期的某個階段。很多人會寫這種邏輯：如果流程幾十個豈不是要if到爆炸。還有這「0」、「1」是幾個意思？
  • 用好Java中的枚舉,真的沒有那麼簡單!
    「最近重看 Java 枚舉，看到這篇覺得還不錯的文章，於是簡單翻譯和完善了一些內容，分享給大家，希望你們也能有所收穫。另外，不要忘了文末還有補充哦！ps: 這裡發一篇枚舉的文章，也是因為後面要發一篇非常實用的關於 SpringBoot 全局異常處理的比較好的實踐裡面就用到了枚舉。
  • Java中枚舉的線程安全性及序列化問題
    Java SE5提供了一種新的類型-Java的枚舉類型，關鍵字enum可以將一組具名的值的有限集合創建為一種新的類型，而這些具名的值可以作為常規的程序組件使用，這是一種非常有用的功能。本文將深入分析枚舉的源碼，看一看枚舉是怎麼實現的，他是如何保證線程安全的，以及為什麼用枚舉實現的單例是最好的方式。要想看源碼，首先得有一個類吧，那麼枚舉類型到底是什麼類呢？是enum嗎？
  • 一文搞懂 Java 中的枚舉,寫得非常好!
    創建enum時，編譯器會為你生成一個相關的類，這個類繼承自 java.lang.Enum。但是這句話需要拆分去理解，讓我們細細道來。枚舉可以添加方法在概念章節提到了，枚舉值默認為從0開始的有序數值。那麼問題來了：如何為枚舉顯示的賦值。Java 不允許使用 = 為枚舉常量賦值如果你接觸過C/C++，你肯定會很自然的想到賦值符號 =。
  • Java基礎之Socket篇
    細心的小夥伴，可能會注意到關於**close方法使用了synchronized關鍵詞修飾了**，大家如果不懂synchronized關鍵詞，可以閱讀以下幾篇文章：如果有小夥伴們，看完這兩篇文章還理解不了。
  • 為啥用枚舉,枚舉有哪些用法?
    : No enum constant Season.nyfor2020 at java.lang.Enum.valueOf(Enum.java:238) at Season.valueOf(Season.java:5) at Test.main(Season.java:11)Season.values()方法和Season.ordinal()方法
  • 為什麼建議你使用枚舉?
    在 Java 語言中和枚舉類相關的，還有兩個枚舉集合類 java.util.EnumSet 和 java.util.EnumMap，使用它們可以實現更多的功能。那有人就說了，那就使用常量字符唄，這總不會還不知道語義吧？
  • 用好 Java 中的枚舉,真的沒有那麼簡單!
    1.概覽在本文中，我們將看到什麼是 Java 枚舉，它們解決了哪些問題以及如何在實踐中使用  Java 枚舉實現一些設計模式。enum關鍵字在 java5 中引入，表示一種特殊類型的類，其總是繼承java.lang.Enum類，更多內容可以自行查看其官方文檔。
  • 恕我直言,我懷疑你並不會用 Java 枚舉
    開門見山地說吧，enum（枚舉）是 Java 1.5 時引入的關鍵字，它表示一種特殊類型的類，默認繼承自 java.lang.Enum。為了證明這一點，我們來新建一個枚舉 PlayerType：public enum PlayerType {    TENNIS,    FOOTBALL,    BASKETBALL}
  • 學Java反射,看這篇就夠了 | 原力計劃
    這麼多的問題，這是在挑釁啊，既然如此，那麼我想起來宮本的那句：想挑戰的，一個一個來。先解決第一個問題。 此為何物 百度看了看反射的介紹：超過二秒後，我表示看不下去了，就不能簡單點嗎？這是給人看的嗎？像我這種人，是看不下去的。我們來一句話定義反射：反射就是把 Java 類中的各種成分映射成一個個的 Java 對象。