Java 中的枚举类原理及使用详解

悠悠 2024-04-17 23:12 53阅读 0赞

**目录**

1、枚举类的介绍及使用

2、枚举的实现原理

--------------------

#### 1、枚举类的介绍及使用 ####

枚举类型是一种特殊的数据类型，它允许变量为一组预定义的常量。变量的值必须为其预定义的值之一。常见的例子包括罗盘方向(东、西、南、北)和一周的天数。

因为枚举类型的字段是常量，所以它们的名称都是大写字母。

在 Java 中，可以使用 enum 关键字定义枚举类型。例如，可以指定一个星期的枚举类型为：

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

当需要表示一组固定的常量时，应该使用枚举类型。比如太阳系中的行星，以及在编译时就知道所有可能值的数据集——例如，菜单上的选项、命令行标志等等。

**为什么使用枚举？**

枚举定义常量比使用类定义常量更加简洁，使用枚举在类型安全、使用便捷性、重复值的校验上都要比使用类更加人性化。

下面是一些代码，展示了如何使用上面定义的 Day 枚举：

public class EnumTest {
        Day day;
        
        public EnumTest(Day day) {
            this.day = day;
        }
        
        public void tellItLikeItIs() {
            switch (day) {
                case MONDAY:
                    System.out.println("Mondays are bad.");
                    break;
                        
                case FRIDAY:
                    System.out.println("Fridays are better.");
                    break;
                             
                case SATURDAY: case SUNDAY:
                    System.out.println("Weekends are best.");
                    break;
                            
                default:
                    System.out.println("Midweek days are so-so.");
                    break;
            }
        }
        
        public static void main(String[] args) {
            EnumTest firstDay = new EnumTest(Day.MONDAY);
            firstDay.tellItLikeItIs();
            EnumTest thirdDay = new EnumTest(Day.WEDNESDAY);
            thirdDay.tellItLikeItIs();
            EnumTest fifthDay = new EnumTest(Day.FRIDAY);
            fifthDay.tellItLikeItIs();
            EnumTest sixthDay = new EnumTest(Day.SATURDAY);
            sixthDay.tellItLikeItIs();
            EnumTest seventhDay = new EnumTest(Day.SUNDAY);
            seventhDay.tellItLikeItIs();
        }
    }

输出为：

Mondays are bad.
    Midweek days are so-so.
    Fridays are better.
    Weekends are best.
    Weekends are best.

Java 的枚举类比其他语言中的枚举类强大得多。使用 enum 声明一个枚举类。枚举类主体可以包括方法和其他字段，同时编译器在创建枚举时也会自动添加一些特殊方法。例如，它们有一个静态值方法，该方法返回一个数组，该数组按照声明的顺序包含枚举的所有值。此方法通常与 for-each 构造结合使用，用来遍历枚举类的值。例如，下面的代码遍历 Planet 枚类中的所有值。

for (Planet p : Planet.values()) {
        System.out.printf("Your weight on %s is %f%n",
                          p, p.surfaceWeight(mass));
    }

**注意：**所有枚举都隐式地扩展 java.lang.Enum 类。因为 Java 不支持多重继承，一个类只能继承一个父类，所以枚举类不能再继承其他任何的类。

例子中的 Planet 是一个枚举类，表示太阳系中的行星。行星的质量和半径一般都会保持不变，所以可以定义为固定的常量。

Planet 类中的每个枚举常量都声明了质量和半径参数的值，这些值会在创建常量的时侯传递给构造函数。Java 要求先定义常量，然后再定义其他字段或方法。同样，当存在字段和方法时，枚举常量列表也必须以分号结束。// 枚举类中要求先定义常量列表

**注意：**枚举类的构造函数必须是包私有或私有访问权限。它会自动创建在枚举体开头部分定义的常量，你不能自己调用枚举类的构造函数。

除了定义枚举类的属性和构造函数外，在 Planet 类中还可以定义一些方法。比如，用来检索每个行星上物体的表面重力和重量。示例程序如下：// 枚举类它是一个类，用来定义常量，除了不能继承其他类，具备类的其他特征。

public enum Planet {
        MERCURY (3.303e+23, 2.4397e6),
        VENUS   (4.869e+24, 6.0518e6),
        EARTH   (5.976e+24, 6.37814e6),
        MARS    (6.421e+23, 3.3972e6),
        JUPITER (1.9e+27,   7.1492e7),
        SATURN  (5.688e+26, 6.0268e7),
        URANUS  (8.686e+25, 2.5559e7),
        NEPTUNE (1.024e+26, 2.4746e7);
    
        private final double mass;   // 千克
        private final double radius; // 米
    
        Planet(double mass, double radius) {
            this.mass = mass;
            this.radius = radius;
        }
    
        private double mass() { return mass; }
        private double radius() { return radius; }
    
        // 万有引力常数  (m3 kg-1 s-2)
        public static final double G = 6.67300E-11;
    
        // 方法：计算表面重力
        double surfaceGravity() {
            return G * mass / (radius * radius);
        }
    
        // 方法：计算表面重力
        double surfaceWeight(double otherMass) {
            return otherMass * surfaceGravity();
        }
    
        public static void main(String[] args) {
            if (args.length != 1) {
                System.err.println("Usage: java Planet <earth_weight>");
                System.exit(-1);
            }
            double earthWeight = Double.parseDouble(args[0]);
            double mass = earthWeight/EARTH.surfaceGravity();
            for (Planet p : Planet.values())
               System.out.printf("Your weight on %s is %f%n",
                                 p, p.surfaceWeight(mass));
        }
    }

#### 2、枚举的实现原理 ####

在使用关键字 enum 创建枚举类并编译后，编译器会生成一个相关的类，这个类继承了 Java API 中的 java.lang.Enum 类，也就是说通过关键字 enum 创建的枚举类在编译后事实上也是一个类，而且该类继承了 java.lang.Enum 类。

java.lang.Enum 类不允许直接写一个类进行继承，同时 Enum 类内部有一个构造函数，该构造函数只能被编译器调用，无法由程序员手动操作。

下面定义 EnumDemo.java ，通过编译查看生成的 class 文件来验证这个结论：

public class EnumDemo {
        //定义枚举类型
        enum Day {
            MONDAY, TUESDAY, WEDNESDAY,
            THURSDAY, FRIDAY, SATURDAY, SUNDAY
        }
    
        public static void main(String[] args){
            //直接引用
            Day day =Day.MONDAY;
        }
    }

编译后生成的 class 文件：

$ ls                  //查看目录下的java文件
    EnumDemo.java
    $ javac EnumDemo.java //利用javac命令编译EnumDemo.java
    $ ls                  //查看生成的class文件，注意有Day.class和EnumDemo.class 两个
    Day.class  EnumDemo.class  EnumDemo.java

利用 javac 编译前面定义的 EnumDemo.java 文件后分别生成了 Day.class 和 EnumDemo.class 文件，而 Day.class 就是枚举类，这也就验证了前面所说的使用关键字 enum 定义枚举类并编译后，编译器会自动帮助我们生成一个与枚举相关的类。

接下来再来看看反编译 Day.class 文件，真相都在这里了：

//反编译Day.class
    final class Day extends Enum
    {
        //编译器为我们添加的静态的values()方法
        public static Day[] values()
        {
            return (Day[])$VALUES.clone();
        }
        //编译器为我们添加的静态的valueOf()方法，注意间接调用了Enum也类的valueOf方法
        public static Day valueOf(String s)
        {
            return (Day)Enum.valueOf(com/zejian/enumdemo/Day, s);
        }
        //私有构造函数
        private Day(String s, int i)
        {
            super(s, i);
        }
         //前面定义的7种枚举实例
        public static final Day MONDAY;
        public static final Day TUESDAY;
        public static final Day WEDNESDAY;
        public static final Day THURSDAY;
        public static final Day FRIDAY;
        public static final Day SATURDAY;
        public static final Day SUNDAY;
        private static final Day $VALUES[];
    
        static 
        {    
            //实例化枚举实例
            MONDAY = new Day("MONDAY", 0);
            TUESDAY = new Day("TUESDAY", 1);
            WEDNESDAY = new Day("WEDNESDAY", 2);
            THURSDAY = new Day("THURSDAY", 3);
            FRIDAY = new Day("FRIDAY", 4);
            SATURDAY = new Day("SATURDAY", 5);
            SUNDAY = new Day("SUNDAY", 6);
            $VALUES = (new Day[] {
                MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
            });
        }
    }

从反编译的代码可以看出，编译器确实帮我们生成了一个 Day.calss ，该类是 final 类型的，所以无法被继承，而且类继承了 java.lang.Enum 类（抽象类），也无法再继承其他类。

除此之外，编译器还生成了 7 个 Day 类型的实例对象，分别对应枚举类中定义的 7 个日期，这也充分说明了使用关键字 enum 定义的 Day 类型中的每种日期枚举常量，也是实实在在的 Day 实例对象，只不过代表的内容不一样而已。// 定义的常量也是对象

注意编译器还为我们生成了两个静态方法，分别是 values() 和 valueOf()，稍后还会分析它们的用法，到此我们也就明白了，使用关键字 enum 定义的枚举类型，在编译后，也会转换成为一个实实在在的类，在该类中，会存在每个在枚举类型中定义好的变量的对应实例对象，如上述的 MONDAY 枚举类型对应 public static final Day MONDAY，同时编译器还会为该类创建两个方法，分别是 values() 和 valueOf()。

ok~，到此相信我们对枚举的实现原理也比较清晰了，下面深入了解一下 java.lang.Enum 类以及 values() 和 valueOf() 的用途。

> Java 从 JDK1.5 开始支持枚举，也就是说，Java 一开始是不支持枚举的，就像泛型一样，都是 JDK1.5 才加入的新特性。通常一个特性如果在一开始没有提供，在语言发展后期才添加，就会遇到向后兼容性的问题。所以，像 Java 在 1.5 中引入的很多特性，为了向后兼容，编译器会帮我们写的源代码做很多事情，比如，泛型为什么会存在类型擦除，为什么会生成桥接方法，foreach 的迭代，自动装箱/拆箱等，这里有个术语叫“语法糖”，而编译器的特殊处理就是“解语法糖”。// Java 的语法糖
> 
>  因此，枚举实际上就是对定义常量的一个新的封装，只是对封装处理都由编译器来做。

**编译器生成的 values() 方法与 valueOf() 方法**

values() 方法和 valueOf(String name) 方法是编译器生成的 static 方法，下面通过代码来演示这两个方法的作用：

Day[] days2 = Day.values();
    System.out.println("day2:"+Arrays.toString(days2));
    Day day = Day.valueOf("MONDAY");
    System.out.println("day:"+day);
    
    /**
     输出结果:
     day2:[MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY]
     day:MONDAY
     */

从结果可知道，values() 方法的作用就是获取枚举类中的所有变量，并作为数组返回，而 valueOf(String name) 方法的作用就是根据名称获取枚举变量，由于 values() 方法是由编译器插入到枚举类中的 static 方法，所以如果将枚举实例向上转型为 Enum，那么 values() 方法将无法被调用，因为 Enum 类中并没有values()方法，valueOf() 方法也是同样的道理。

Day[] ds=Day.values();  //正常使用
    Enum e = Day.MONDAY;    //向上转型Enum
    e.values();             // error...无法调用,没有此方法

至此，Java 中的枚举类原理及使用介绍完毕。