Java枚舉解讀

Java枚舉

枚舉類概念的理解與定義

• 一個類的對象是有限個，肯定的，咱們稱此爲枚舉類。
• 當須要定義和維護一組常量時，強烈建議使用枚舉類。
• 若是一個枚舉類中只有一個對象，則能夠做爲單例模式的實現方式。

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

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

枚舉類的定義

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

1. jdk 5.0以前，自定義枚舉類方式
2. jdk 5.0以後，Enum關鍵字方式定義

實踐

1、準備工做

咱們新建一個 Java Project ，並建立一個包，以及一個測試類

2、自定義枚舉的三種方式(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 這種寫法，一來方便記憶，二來可讀性高。那麼官方的作法時怎樣的呢？咱們點進去源碼看一下

1. 首先 Calendar 自己是一個抽象類，實現了序列化、克隆、以及比較排序接口，這邊和咱們枚舉沒有太大關係，咱們繼續往下看
   

2. 在抽象類中，定義了不少個靜態常量進行維護，而當咱們須要使用時，直接調用，這樣就比咱們寫一個個的具體值要方便和易用了。

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 關鍵字定義枚舉類

3、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

總結

1. jdk 5.0以前咱們能夠自定義枚舉類，jdk 5.0以後使用enum關鍵字定義枚舉類，枚舉類默認繼承自java.lang.Enum，使用枚舉類將常量組織起來，便於統一管理。例如錯誤碼、狀態機等場景中，較爲合適使用枚舉類。
2. 枚舉類經常使用方法介紹及枚舉類實現抽象類、接口等抽象方法的兩種方式。
3. 枚舉經常使用的工具類及與switch使用的場景。