Java 基础学习四：Enum 枚举类

墨蓝 2022-06-01 06:28 258阅读 0赞

# Java 基础学习四：枚举类 #

参考  
[IBM DeveloperWorks 学习][IBM DeveloperWorks]  
[java enum(枚举)使用详解 + 总结][java enum_ _]  
[Java Design Demo–枚举类型–避免嵌套过多][Java Design Demo] – 思维转变，建议参考  
[Java枚举中嵌套枚举用例][Java]

# 背景 #

## 枚举出现前的状况 ##

在 java 语言中还没有引入枚举类型之前，表示枚举类型的常用模式是声明一组常量（通常利用 public final static 方法定义）。

public class Season { 
        public static final int SPRING = 1; // 春天
        public static final int SUMMER = 2; // 夏天
        public static final int AUTUMN = 3; // 秋天
        public static final int WINTER = 4; // 冬天
    }

这种方法称作 **int枚举模式**。  
可这种模式有什么问题呢，我们都用了那么久了，应该没问题的。通常我们写出来的代码都会考虑它的安全性、易用性和可读性。  
1、首先我们来考虑一下它的类型安全性（当然这种模式不是类型安全的）  
比如说我们设计一个函数，要求传入春夏秋冬的某个值。但是使用 int类型，我们无法保证传入的值为合法。

private String getChineseSeason(int season){
            StringBuffer result = new StringBuffer();
            switch(season){
                case Season.SPRING :
                    result.append("春天");
                    break;
                case Season.SUMMER :
                    result.append("夏天");
                    break;
                case Season.AUTUMN :
                    result.append("秋天");
                    break;
                case Season.WINTER :
                    result.append("冬天");
                    break;
                default :
                    result.append("地球没有的季节");
                    break;
            }
            return result.toString();
        }
    
       public void doSomething(){
        // 正常使用场景
        System.out.println(this.getChineseSeason(Season.SPRING));
    
        // 不正常使用场景：这不是我们需要的场景，但编译的确能通过，导致类型不安全问题
        System.out.println(this.getChineseSeason(5));
       }

程序 getChineseSeason(Season.SPRING) 是我们预期的使用方法。可 getChineseSeason(5) 显然就不是了，而且编译能通过。这显然就不符合Java程序的类型安全。

2、接下来我们来考虑一下这种模式的可读性  
使用枚举的大多数场合，我们都需要方便得到枚举类型的字符串表达式。如果将int枚举常量打印出来，我们所见到的就是一组魔鬼数字（特别是读日志时），看到 1 很难联想到代表春天。  
我们可能会想到使用String常量代替 int常量。虽然它为这些常量提供了可打印的字符串，但是它会导致性能问题，因为它依赖于字符串的比较操作，所以这种模式也是我们不期望的。

从类型安全性和程序可读性两方面考虑，int和String枚举模式的缺点就显露出来了。

## Java 1.5 引入枚举 ##

**Java 1.5 引入的枚举，很好地避免掉了 int和String枚举模式的缺点，同时还有一些额外的好处。**

枚举类型（Enumerated Type）是将一组类似的值包含到一种类型当中。而这种枚举类型的名称则会被定义成独一无二的类型描述符，在这一点上和常量的定义相似。不过相比较常量类型，枚举类型可以为申明的变量提供更大的取值范围。

> 1、增加了 **命名空间**  
> 不用枚举时，季节只是类的属性，引用的时候不得不通过类来访问。但如果常量类里引入多组常量时就有可能造成混淆，当然也可以加一个“SEASON\_”前缀，但要加7个前缀，读和写也相应的增加了麻烦。  
> 2、增强了 **一致性**  
> int枚举属于编译期常量，编译后，所有客户端和服务器端引用的地方，会直接将整数值写入。这样，当你修改旧的枚举整数值后或者增加新的枚举值后，所有引用地方代码都需要重新编译，否则运行时刻就会出现错误。  
> 3、扩大了 switch 语句使用范围。 5.0 之前，Java 中 switch 的值只能够是简单类型，比如 int、byte、short、char, 有了枚举类型之后，就可以使用对象了。

用枚举重写上面代码：

public class UseSeason { 
        /** * 将英文的季节转换成中文季节 * @param season * @return */
        public String getChineseSeason(Season season){
            StringBuffer result = new StringBuffer();
            switch(season){
                case SPRING :
                    result.append("[中文：春天，枚举常量:" + season.name() + "，数据:" + season.getCode() + "]");
                    break;
                case AUTUMN :
                    result.append("[中文：秋天，枚举常量:" + season.name() + "，数据:" + season.getCode() + "]");
                    break;
                case SUMMER :
                    result.append("[中文：夏天，枚举常量:" + season.name() + "，数据:" + season.getCode() + "]");
                    break;
                case WINTER :
                    result.append("[中文：冬天，枚举常量:" + season.name() + "，数据:" + season.getCode() + "]");
                    break;
                default :
                    result.append("地球没有的季节 " + season.name());
                    break;
            }
            return result.toString();
        }
    
        public void doSomething(){
            for(Season s : Season.values()){
                System.out.println(getChineseSeason(s));//这是正常的场景
            }
            //此处已经是编译不通过了，这就保证了类型安全
            //System.out.println(getChineseSeason(5)); 
        }
    
        public static void main(String[] arg){
            UseSeason useSeason = new UseSeason();
            useSeason.doSomething();
        }
    }

### 枚举类型源码分析 ###

package java.lang;
    
    import java.io.Serializable;
    import java.io.IOException;
    import java.io.InvalidObjectException;
    import java.io.ObjectInputStream;
    import java.io.ObjectStreamException;
    
    /** * 枚举类型符合通用模式 Class Enum<E extends Enum<E>>，而 E 表示枚举类型的名称。 * 枚举类继承的是 Enum 类（非 Object） */
    public abstract class Enum<E extends Enum<E>>
            implements Comparable<E>, Serializable {
        /** * 枚举常量的名称（在枚举声明中对其进行声明） */
        private final String name;
    
        /** * 返回枚举常量的名称，用toString()方法获得常量名而不是访问该变量 */
        public final String name() {
            return name;
        }
    
        /** * 枚举常量的位置（下标，从0开始） * 为复杂的基于枚举的数据结构设计。像：{ @link java.util.EnumSet}、{ @link java.util.EnumMap}. */
        private final int ordinal;
    
        /** * 返回枚举常量的位置 */
        public final int ordinal() {
            return ordinal;
        }
    
        /** * 枚举类型的每一个值都将映射到 protected Enum(String name, int 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;
        }
    
        /** * 返回与此枚举常量的枚举类型相对应的 Class 对象 */
        @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);
        }
    
        /** * 枚举类不该有finalize()方法 */
        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");
        }
    }

### 定义 Enum 类 ###

简单定义：**enum** \+ **枚举类名称** \+ **\{**  枚举值1, 枚举值2 … 枚举值n **\}**

enum SeasonType { SPRING, SUMMER, AUTUMN, WINTER }
    
    // 这段代码实际上调用了 4 次 Enum(String name, int ordinal)：
    new Enum<EnumTest>("SPRING", 0);
    new Enum<EnumTest>("SUMMER", 1);
    new Enum<EnumTest>("AUTUMN", 2);
    new Enum<EnumTest>("WINTER", 3);

定义形式看似简单，但它不仅是简单地将整形数值转换成对象，而是将枚举类型定义转变成一个完整功能的类定义。

枚举类是一个特殊的类，它一样可以有自己的成员变量、方法，可以实现一个或多个接口，也可以定义自己的构造器。但枚举类与普通类还是有区别的：

1.  创建枚举类型要使用 enum 关键字，隐含了所创建的类型都是 java.lang.Enum 类的子类（即枚举类默认继承 java.lang.Enum 类，而非 Object 类），因此枚举类不能显示 extends 其他父类；但枚举类仍可以 implements 一个或多个接口（Interface）；
2.  Java 为 Enum 类型提供了高质量的实现，比如默认实现 Comparable 和 Serializable 接口，让开发者一般情况下不用关心这些细节；
3.  枚举可以单独定义在一个文件中，也可以嵌在其它Java类中；
4.  使用 enum 定义、非抽象的枚举类默认会使用 final 修饰，因此枚举类不能派生子类；
5.  枚举类的所有实例必须在枚举类的第一行显式列出，否则这个枚举类永远都不能产生实例。枚举值之间用英文逗号`","`隔开，枚举值结束后用英文分号`";"`结束（如果枚举类没有属性及方法时，可以不带结束符）；**系统自动给每个实例添加 public static final 修饰，无须显式添加**；
6.  枚举类中的枚举值可以没有参数，也可以有多个参数；
7.  枚举类的**构造器只能使用 private 修饰符**（如果不写，默认 private 修饰符）；
8.  可以定义新的属性（默认 private 修饰）；
9.  可以定义新的方法；

# 实战 #

枚举在各个语言当中都有着广泛的应用，通常用来表示诸如**颜色**、**方式**、**类别**、**状态**等等**数目有限、形式离散、表达又极为明确的量**。

## 参数 ##

### 无参 ###

public enum SeasonType {
        SPRING, SUMMER, AUTUMN, WINTER
    }

应用

// 根据实际情况选择下面的用法即可
    SeasonType springType = SeasonType.SPRING;    // 输出 SPRING 
    String springString = SeasonType.SPRING.toString();    // 输出 SPRING

### 一参 ###

public enum SeasonType {
        // 通过构造函数传递参数并创建实例
        SPRING("spring"), SUMMER("summer"), AUTUMN("autumn"), WINTER("winter");
    
        // 定义实例对应的参数
        private String msg;
    
        // 必写：通过此构造器给枚举值创建实例
        SeasonType(String msg) {
            this.msg = msg;
        }
    
        // 通过此方法可以获取到对应实例的参数值
        public String getMsg() {
            return msg;
        }
    }

应用

// 当我们为某个实例类赋值的时候可使用如下方式
    String msg = SeasonType.SPRING.getMsg();    // 输出 spring

### 两参 ###

public enum Season {
        // 通过构造函数传递参数并创建实例
        SPRING(1, "spring"), SUMMER(2, "summer"),  AUTUMN(3, "autumn"), WINTER(4, "winter");
    
        // 定义实例对应的参数
        private int key;
        private String msg;
    
        // 必写：通过此构造器给枚举值创建实例
        Season(int key, String msg) {
            this.key = key;
            this.msg = msg;
        }
    
        // 通过此方法可以获取到对应实例的 key 值
        public Integer getKey() {
            return key;
        }
    
        // 通过此方法可以获取到对应实例的 msg 值
        public String getMsg() {
            return msg;
        }
    
        // 很多情况，我们可能从前端拿到的值是枚举类的 key ，然后就可以通过以下静态方法获取到对应枚举值
        public static String getValueByKey(int key) {
            for (Season season : Season.values()) {
                if (season.getKey() == key) {
                    return season.getValue();
                }
            }
            throw new IllegalArgumentException("No element matches " + key);
        }
    }

应用

// 输出 key 为 1 的枚举值实例
    Season season = Season.valueofKey(1);
    // 输出 SPRING 实例对应的 key
    Integer key = Season.SPRING.getKey();
    // 输出 SPRING 实例对应的 msg
    String msg = Season.SPRING.getMsg();

## 读取：遍历或switch ##

switch 语句也能用 enum，可读性更强。

enum Signal {
        RED, GREEN, YELLOW
    }
    
    public class TrafficLight {
        public static void main(String[] args) {
            // 遍历
            for (Signal s : Signal.values()) {
                System.out.println(s.toString()); // 依次输出三行值：RED, GREEN, YELLOW
            }
    
            System.out.println("----------------我是分隔线------------------");
    
            // Switch
            Signal color = Signal.RED;
            switch (color) {
                case RED:
                    System.out.println("红灯停");// 输出
                    break;
                case GREEN:
                    System.out.println("绿灯行");
                    break;
                case YELLOW:
                    System.out.println("黄灯亮了等一等");
                    break;
            }
    
            System.out.println("getDeclaringClass(): " + color.getDeclaringClass().getName());// getDeclaringClass(): com.wsh.test.Signal
    
            System.out.println("name(): " + color.name());// name(): RED
            System.out.println("toString(): " + color.toString());// toString(): RED
    
            System.out.println("ordinal(): " + color.ordinal());// ordinal(): 0
        }
    
    }

## 覆盖枚举的方法 ##

下面给出一个toString()方法覆盖的例子。

public enum Color {
        RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
        // 成员变量 
        private String name;
        private int index;
        // 构造方法 
        private Color(String name, int index) {
            this.name = name;
            this.index = index;
        }
        //覆盖方法 
        @Override
        public String toString() {
            return this.index+"_"+this.name;
        }
    }

## 实现接口 ##

所有的枚举都继承自java.lang.Enum类。由于Java 不支持多继承，所以枚举对象不能再继承其他类。但可以实现任意接口。

public interface Behaviour {
        void print();
        String getInfo();
    }
    public enum Color implements Behaviour{
        RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
        // 成员变量 
        private String name;
        private int index;
        // 构造方法 
        private Color(String name, int index) {
            this.name = name;
            this.index = index;
        }
        //接口方法 
        @Override
        public String getInfo() {
            return this.name;
        }
        //接口方法 
        @Override
        public void print() {
            System.out.println(this.index+":"+this.name);
        }
    }

## 使用接口组织枚举 ##

public interface Food {
        enum Coffee implements Food{
            BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO
        }
        enum Dessert implements Food{
            FRUIT, CAKE, GELATO
        }
    }

## 关于枚举集合的使用 ##

java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复；EnumMap中的key是enum类型，而value则可以是任意类型。

[IBM DeveloperWorks]: https://www.ibm.com/developerworks/cn/java/j-lo-enum/
[java enum_ _]: https://www.cnblogs.com/hyl8218/p/5088287.html
[Java Design Demo]: https://blog.csdn.net/b275518834/article/details/8456927
[Java]: https://blog.csdn.net/wonking666/article/details/75575253