Java 枚舉的基本使用方法及實際使用場景

更新時間：2025年06月05日 14:21:08 作者：aDakkke

枚舉是 Java 中一種特殊的類,用于定義一組固定的常量,枚舉類型提供了更好的類型安全性和可讀性,適用于需要定義一組有限且固定的值的場景,本文給大家介紹Java 枚舉的用法及實際使用場景,感興趣的朋友一起看看吧

一、什么是枚舉？

枚舉（enum）是 Java 中一種特殊的類，用于定義一組固定的常量。枚舉類型提供了更好的類型安全性和可讀性，適用于需要定義一組有限且固定的值的場景。枚舉常量是 public static final 的，可以直接通過枚舉類名訪問。

枚舉的主要特點：

類型安全：限制了變量的取值范圍，避免了無效值的傳入。
代碼簡潔：枚舉可以代替大量的常量定義，使代碼更簡潔。
易于維護：枚舉將相關(guān)的常量集中在一起，便于維護擴展。

二、枚舉的基本使用方法

定義枚舉

通過 enum 關(guān)鍵字定義，語法如下：

public enum 枚舉名 {
    常量1,
    常量2,
    常量3;
}

例如：星期

public enum Week {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;
}

另外，枚舉還可以定義屬性和方法，甚至可以定義構(gòu)造函數(shù)。例如：

public enum Status {
    ACTIVE(1, "激活"),
    INACTIVE(2, "未激活");
    private int code;
    private String description;
    // 枚舉的構(gòu)造函數(shù)
    Status(int code, String description) {
        this.code = code;
        this.description = description;
    }
    public int getCode() {
        return code;
    }
    public String getDescription() {
        return description;
    }
}

枚舉類繼承自 java.lang.Enum ，有一些自帶的方法：比如 name()、ordinal()、values()、valueOf(String)。不過我一般比較少使用這些方法，實際中我會按下面使用枚舉。

三、實際使用場景

代替常量

枚舉可以用來替代傳統(tǒng)的常量定義（如 public static final int），提供更好的可讀性和類型安全性。

狀態(tài)機

表示有限的狀態(tài)，比如狀態(tài)、類型等業(yè)務數(shù)據(jù)。例如：

public enum Status
{
    OK("0", "正常"), DISABLE("1", "停用"), DELETED("2", "刪除");
    private final String code;
    private final String info;
    Status(String code, String info)
    {
        this.code = code;
        this.info = info;
    }
    public String getCode()
    {
        return code;
    }
    public String getInfo()
    {
        return info;
    }
	public static String getInfoByCode(String code){
        for (Status value : values()) {
            if (code.equals(value.code))return value.info;
        }
        return null;
    }
    public static List<String> getCodeList(){
        List<String> codeList = new ArrayList<>();
        for (Status value : Status.values()) {
            codeList.add(value.getCode());
        }
        return codeList;
    }
}

四、更多用法

1.實現(xiàn)接口

枚舉可以實現(xiàn)接口，從而擴展功能。
像上文中自定義方法 getCode()、getInfo() 、getInfoByCode() 和 getCodeList() 都是單獨為這個枚舉創(chuàng)建的。

我們可以定義一個通用的接口。

public interface KeyValueEnum<K, V> {
    K getKey();
    V getValue();
}

然后枚舉類可以修改為：

public enum Status implements KeyValueEnum<String, String> {
    OK("0", "正常"), DISABLE("1", "停用"), DELETED("2", "刪除");
    private String key;
    private String value;
    Status(String key, String value) {
        this.key = key;
        this.value = value;
    }
    @Override
    public String getKey() {
        return key;
    }
    @Override
    public String getValue() {
        return value;
    }
}

getInfoByCode() 和 getCodeList()可以創(chuàng)建為工具類。

import java.util.ArrayList;
import java.util.List;
public class EnumUtils {
    /**
     * 根據(jù) key 獲取枚舉的 value
     *
     * @param enumClass 枚舉類
     * @param key       key
     * @param <K>       key 類型
     * @param <V>       value 類型
     * @param <E>       枚舉類型
     * @return 對應的 value，如果未找到則返回 null
     */
    public static <K, V, E extends Enum<E> & KeyValueEnum<K, V>> V getValueByKey(Class<E> enumClass, K key) {
        for (E value : enumClass.getEnumConstants()) {
            if (value.getKey().equals(key)) {
                return value.getValue();
            }
        }
        return null;
    }
    /**
     * 根據(jù) value 獲取枚舉的 key
     *
     * @param enumClass 枚舉類
     * @param value     value
     * @param <K>       key 類型
     * @param <V>       value 類型
     * @param <E>       枚舉類型
     * @return 對應的 key，如果未找到則返回 null
     */
    public static <K, V, E extends Enum<E> & KeyValueEnum<K, V>> K getKeyByValue(Class<E> enumClass, V value) {
        for (E e : enumClass.getEnumConstants()) {
            if (e.getValue().equals(value)) {
                return e.getKey();
            }
        }
        return null;
    }
    /**
     * 獲取枚舉類的所有 key 值
     *
     * @param enumClass 枚舉類
     * @param <K>       key 類型
     * @param <V>       value 類型
     * @param <E>       枚舉類型
     * @return 包含所有 key 的列表
     */
    public static <K, V, E extends Enum<E> & KeyValueEnum<K, V>> List<K> getKeyList(Class<E> enumClass) {
        List<K> keyList = new ArrayList<>();
        for (E value : enumClass.getEnumConstants()) {
            keyList.add(value.getKey());
        }
        return keyList;
    }
}

使用工具類：

public class Main {
    public static void main(String[] args) {
        // 獲取 Status 枚舉的所有 key 值
        List<String> keyList = EnumUtils.getKeyList(Status.class);
        System.out.println(keyList); // 輸出 ["0", "1", "2"]
		// 根據(jù) key 獲取 value
        String statusValue = EnumUtils.getValueByKey(Status.class, 1);
        System.out.println(statusValue); // 輸出 "停用"
        // 根據(jù) value 獲取 key
        Integer statusKey = EnumUtils.getKeyByValue(Status.class, "正常");
        System.out.println(statusKey); // 輸出 0
    }
}

2.單例模式

枚舉可以用來實現(xiàn)單例模式，確保一個類只有一個實例。

public enum Singleton {
    INSTANCE;
    public void example() {
        System.out.println("枚舉實現(xiàn)單例模式");
    }
}

那么，為什么枚舉可以實現(xiàn)單例模式呢？

枚舉（enum）作為單例模式是一種非常優(yōu)雅且安全的實現(xiàn)方式。主要是因為：

枚舉常量在 JVM 中是唯一的，每個枚舉常量都是枚舉類的一個實例。
枚舉常量在類加載時被初始化，且只會初始化一次。
枚舉的構(gòu)造函數(shù)是私有的，無法通過反射或手動調(diào)用構(gòu)造函數(shù)創(chuàng)建新的實例。
枚舉的序列化和反序列化由 JVM 保證，反序列化時不會創(chuàng)建新的實例。

3.策略模式

枚舉可以用來實現(xiàn)簡單的策略模式，每個枚舉常量可以定義自己的行為。
比如：進行一些運算。

public enum Operation {
    ADD {
        public int apply(int a, int b) {
            return a + b;
        }
    },
    SUBTRACT {
        public int apply(int a, int b) {
            return a - b;
        }
    };
    public abstract int apply(int a, int b);
}