Java Enum数据类型

朱雀 2021-11-09 19:10 348阅读 0赞

说明,这篇文章的环境是oracle jdk1.8, idea.

枚举是一种数据类型，具有集合的一些特点，可以存放多个元素，但存储对象有限且固定，

枚举也有比较常见的使用场景，如我们需要表达性别（男、女），颜色（红、黄、蓝），星期（星期一、星期二...星期日），四季（春、夏、秋、冬），地理位置（东、西、南、北），方向（前、后、左、右）等，这些场景都非常适合枚举。

java中使用enum来定义枚举，和class，interface具有同样的等级，(注意是enum，而不是Enum)，定义枚举可以有两种情况

**第一种：默认构造器（空构造器）**

/**
     * @author zk
     * @Description:
     * @date 2019-08-01 17:04
     */
    public enum Quarter1 {
    
        SPRING,SUMMER,AUTUMN,WINTER;
    
    }

未定义成员变量和成员方法，省略了private Quarter() \{\}

简单说明一下：枚举enum的构造器只能是private

反编译之后.class文件是:

//
    // Source code recreated from a .class file by IntelliJ IDEA
    // (powered by Fernflower decompiler)
    //
    
    public enum Quarter1 {
        SPRING,
        SUMMER,
        AUTUMN,
        WINTER;
    
        private Quarter1() {
        }
    }

上面的源码是IDEA自己打开之后的,使用其他工具 jad 编译之后是这样的,就知道其实枚举还是类

工具可以在QQ群:965125360 中工具中找到.

使用方法也很简单  , 在cmd 中输入: jad Quarter1.class

就会生成一个Quarter1.jad 文件, 使用记事本打开就看得到了. 里面的中文注释是我加上去的.

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
    // Jad home page: http://www.kpdus.com/jad.html
    // Decompiler options: packimports(3) 
    // Source File Name:   Quarter1.java
    
    
    //final类,不可以继承
    public final class Quarter1 extends Enum
    {
    
    //static方法
        public static Quarter1[] values()
        {
            return (Quarter1[])$VALUES.clone();
        }
    
        public static Quarter1 valueOf(String name)
        {
            return (Quarter1)Enum.valueOf(Quarter1, name);
        }
    
    //private构造方法.i 其实是index
        private Quarter1(String s, int i)
        {
            super(s, i);
        }
    
        public static final Quarter1 SPRING;
        public static final Quarter1 SUMMER;
        public static final Quarter1 AUTUMN;
        public static final Quarter1 WINTER;
        private static final Quarter1 $VALUES[];
    
    //在静态代码块中进行初始化
        static 
        {
            SPRING = new Quarter1("SPRING", 0);
            SUMMER = new Quarter1("SUMMER", 1);
            AUTUMN = new Quarter1("AUTUMN", 2);
            WINTER = new Quarter1("WINTER", 3);
            $VALUES = (new Quarter1[] {
                SPRING, SUMMER, AUTUMN, WINTER
            });
        }
    }

**第二种：定义了成员变量、带参构造器**

枚举可以定义成员变量，包括成员属性、方法，抽象方法，静态方法等

/**
     * @author zk
     * @Description:
     * @date 2019-08-01 17:05
     */
    public enum Quarter2 {
    
        SPRING("春"),SUMMER("夏"),AUTUMN("秋"),WINTER("冬");
    
        private String name;
    
        //枚举enum的构造器只能是private
        /*private Quarter2(String name) {
            this.name = name;
        }*/
    //这里前面没有加private... 会自动加上
        Quarter2(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        //静态方法
        public static void printName(){
            System.out.println(Quarter2.SUMMER.name);
        }
    
        //可以有抽象方法, 但是抽象方法和上面的实例是不相容的,不能同时存在.,这里注释掉了
        //public abstract void printValue();
    }

注意：枚举和类一样，可以有多个构造器，即有了一个带参构造器，还可以有无参构造器，编译是可以通过的。

除此之外：

1.  枚举enum 默认继承了java.lang.Enum类(
    
        public abstract class Enum<E extends Enum<E>>
                implements Comparable<E>, Serializable )，实现了 java.lang.Seriablizable 和 java.lang.Comparable 两个接口，可序列化以及进行比较；
2.  所有的枚举值都是常量，默认采用了public static final 进行了修饰，enum不是类，自然也不能被继承或实现；
3.  枚举值必须在第一行，否则编译出错；

反编译之后的就是:

//
    // Source code recreated from a .class file by IntelliJ IDEA
    // (powered by Fernflower decompiler)
    //
    
    public enum Quarter2 {
        SPRING("春"),
        SUMMER("夏"),
        AUTUMN("秋"),
        WINTER("冬");
    
        private String name;
    
        private Quarter2(String name) {
            this.name = name;
        }
    
        public String getName() {
            return this.name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public static void printName() {
            System.out.println(SUMMER.name);
        }
    }

使用jad之后的源码是:里面的中文注释是我加上去的.

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
    // Jad home page: http://www.kpdus.com/jad.html
    // Decompiler options: packimports(3) 
    // Source File Name:   Quarter2.java
    
    import java.io.PrintStream;
    
    public final class Quarter2 extends Enum
    {
    
        public static Quarter2[] values()
        {
            return (Quarter2[])$VALUES.clone();
        }
    
        public static Quarter2 valueOf(String name)
        {
            return (Quarter2)Enum.valueOf(Quarter2, name);
        }
    
        private Quarter2(String s, int i, String name)
        {
            super(s, i);
            this.name = name;
        }
    
        public String getName()
        {
            return name;
        }
    
        public void setName(String name)
        {
            this.name = name;
        }
    
        public static void printName()
        {
            System.out.println(SUMMER.name);
        }
    
    //单例
        public static final Quarter2 SPRING;
        public static final Quarter2 SUMMER;
        public static final Quarter2 AUTUMN;
        public static final Quarter2 WINTER;
    //属性
        private String name;
        private static final Quarter2 $VALUES[];
    
        static 
        {
    //这里对中文进行了编码
            SPRING = new Quarter2("SPRING", 0, "\u6625");
            SUMMER = new Quarter2("SUMMER", 1, "\u590F");
            AUTUMN = new Quarter2("AUTUMN", 2, "\u79CB");
            WINTER = new Quarter2("WINTER", 3, "\u51AC");
            $VALUES = (new Quarter2[] {
    //这里的values是直接初始化完成的.
                SPRING, SUMMER, AUTUMN, WINTER
            });
        }
    }

测试:

/**
     * @author zk
     * @Description:
     * @date 2019-08-01 17:09
     */
    public class Test {
    
        public static void main(String[] args) {
            //获取枚举元素
            System.out.println(Quarter2.AUTUMN);
            //调用toString()方法将枚举元素转化为String类型
            System.out.println(Quarter2.AUTUMN.name());
            System.out.println(Quarter2.AUTUMN.toString());
            //获取成员变量
            System.out.println(Quarter2.AUTUMN.getName());
            //静态方法
            Quarter2.printName();
        }
    }

### 枚举遍历 ###

有时候我们需要将枚举元素都取出来作为查询条件，此时就需要进行遍历，通过调用`Quarter.values()`方法

import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @author zk
     * @Description:
     * @date 2019-08-01 17:35
     */
    public class Test3 {
        public static void main(String[] args) {
            //通过values()方法得到Quarter元素的数组
            Quarter2[] quarters = Quarter2.values();
            List<String> quarterParam = new ArrayList<>(quarters.length);
            //将数组中的元素存储到List集合quarterParam中
            for (Quarter2 quarter : quarters) {
                quarterParam.add(quarter.toString());
            }
        }
    }

### switch条件判断 ###

枚举的元素有限且固定，通过switch做条件判断却是正好

Quarter2 quarter = Quarter2.AUTUMN;
            switch (quarter) {
                case SPRING:
                    System.out.println("找到了，是它：" + Quarter2.SPRING);
                    break;
                case SUMMER:
                    System.out.println("找到了，是它：" + Quarter2.SUMMER);
                    break;
                case AUTUMN:
                    System.out.println("找到了，是它：" + Quarter2.AUTUMN);
                    break;
                case WINTER:
                    System.out.println("找到了，是它：" + Quarter2.WINTER);
                    break;
                default:
                    System.out.println("未找到");
                    break;
            }

简单说明一下：其实此处不需要default的内容，或者说将WINTER作为default即可，因为枚举天然有类型限制，你只能传递它已有的元素以及null，不过正常情况下都会提前判断传递的参数是否为null，当switch接收到null时会报java.lang.NullPointerException。

### 枚举比较 ###

判断是否相等

枚举判断两个元素是否相等直接使用==进行判断即可，因为它非类，也无法实例化，存储位置自然也不会根据对象的不同而不同。

//枚举的比较
            System.out.println(Quarter2.AUTUMN==Quarter2.AUTUMN);
            System.out.println(Quarter2.AUTUMN.equals(Quarter2.AUTUMN));
            System.out.println(Quarter2.AUTUMN==Quarter2.SUMMER);
            System.out.println(Quarter2.AUTUMN.equals(Quarter2.SUMMER));
            /**
             true
             true
             false
             false
             */

其底层的equal方法就是:

/**
         * Returns true if the specified object is equal to this
         * enum constant.
         *
         * @param other the object to be compared for equality with this object.
         * @return  true if the specified object is equal to this
         *          enum constant.
         */
        public final boolean equals(Object other) {
            return this==other;
        }

compareTo方法

//比较
            System.out.println(Quarter2.AUTUMN.compareTo(Quarter2.AUTUMN));
            System.out.println(Quarter2.AUTUMN.compareTo(Quarter2.SUMMER));
            System.out.println(Quarter2.SUMMER.compareTo(Quarter2.AUTUMN));
            /**
             0
             1
             -1
             */

### 枚举也可也实现接口 ###

public interface WeatherInterface {
        //获取温度
        String getTemperature(Quarter2 quarter);
    
    }

实现为:

/**
     * @author zk
     * @Description:
     * @date 2019-08-01 17:19
     */
    public enum Quarter3 implements WeatherInterface {
        //这里是个分号
        ;
    
        @Override
        public String getTemperature(Quarter2 quarter) {
            return quarter.getName();
        }
    }

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

如果枚举太多也不好管理，同时条理不够清晰，我们可以通过接口来将多个相关枚举组织在一起进行管理，

public interface Weather {
        enum Quarter implements Weather {
            SPRING, SUMMER, AUTUMN, WINTER;
        }
        enum Temperature implements Weather {
            MODERATE, HEAT, COOL, COLD
        }
        //调用时直接通过Weather.Quarter.SPRING即可。
    }

好了,说完了.