Java暗箱操作之enum

时间:2023-03-08 16:01:27
Java暗箱操作之enum

  enum,即枚举类型,在每种编程语言中都有类似的类型。

  因为用得少,语法规则很难记得住,我每次看到enum都会感到害怕。

  

  一般的enum语法是这样的:

public class MyClass {
private enum Fruit {APPLE, ORANGE, GRAPE, BANANA} //类型定义 private Fruit fruit = Fruit.APPLE; //类型使用 private void useEnum() {
if (fruit == Fruit.ORANGE) {
System.out.println("这是橘子");
}
}
}

  在上面的“类型定义”部分,就发现定义一个enum类型的语句跟常规的Java语法有很大出入,一个类里面一般就是定义变量、函数、内部类这三样东西,但是这句话感觉什么都不是。

  对于enum,包括C++当中的类似的枚举类型,我以前都是采取死记硬背的方法,把它跟其他的语法区别对待来记忆。然而并没有卵用,就是因为枚举类型的“不寻常”,以及用得少,很快就会忘记具体的语法格式。

  前两天看《Effective Java》时,发现有一章专门讲enum的,而且书中强调用enum的好处,以及Java当中的enum相比其他语言的枚举类型的强大之处。我看得一知半解,但对enum这一特殊的东西开始重视起来。

  通过各方面的研究,我发现了enum不为人知的惊天内幕,以及各种暗箱操作。

  首先给出一个最重要的点:enum其实是一个class!

  有了这一逻辑,对于enum的基础语法就理解了一半。把上面的“enum”这个词换成“class”试试会怎样?比如枚举值两边用大括号是怎么回事,是不是清楚了很多?

  

  既然enum就是一个类,那我把 Fruit类(可以这么叫了吧?)的定义换个形式

public class MyClass {
private class Fruit { //把enum换成新的定义
private Fruit() {} //不允许在外面new出Fruit
public static final Fruit APPLE = new Fruit();
public static final Fruit ORANGE = new Fruit();
public static final Fruit GRAPE = new Fruit();
public static final Fruit BANANA = new Fruit();
} private Fruit fruit = Fruit.APPLE; //类型使用 private void useEnum() {
if (fruit == Fruit.ORANGE) {
System.out.println("这是橘子");
}
}
}

  看完这段转换之后的用常规class写的代码,是不是想惊呼一声:这特么不是效果完全一样的代码吗!

  是的,这就是编译器的暗箱操作,编译器一看到enum这个关键字,就会很自然地试图转换成这样。每一个枚举值,并不是C++里面那样的从0开始的int值,而是一个个类实例。而且因为加上了final关键字,知道为什么枚举值是全大写的了吧?又因为加了static关键字,为什么会写出“Fruit.APPLE”这样的静态调用形式了吧?

  这还没有完,以上只是enum定义时的原理,enum在具体使用时,如何遍历?如何输出每个枚举值代表的int值?如何输出每个枚举值的字面字符串值?

  事实上,上面给出的Fruit类很不完整,替代enum的类继承自java.lang.Enum,这是一个抽象类,编译器遇到enum时自动转化为Enum父类中对应的操作。

  

//Enum类的定义
public abstract class Enum<E extends Enum<E>> implements Serializable, Comparable<E> {...}

比如上面的Fruit类其实是这样的

private class Fruit extends java.lang.Enum {
....
}

  来看一下Enum中主要的成员。

//这是Enum类仅有的两个成员变量,比如{APPLE,ORANGE,GRAPE},3个枚举值其实都是Enum类的子类的实例,name分别是"APPLE","ORANGE","GRAPE", ordinal分别是0,1,2

private final String name;    //枚举值的字面字符串表示,比如"APPLE","ORANGE",

private final int ordinal;      //枚举值所代表的int值,跟C++中的枚举类型类似,可以理解为索引,按照定义时顺序,第一个为0,第二个为1,以此类推

  可以通过类似于get方法得到这两个属性值

    //得到字面值
public final String name() {
return name;
} //得到索引值
public final int ordinal() {
return ordinal;
}

  另外在输出枚举值时,输出的是枚举值的字面字符串值,因为调用的是toString()方法

    @Override
public String toString() {
return name;
}

  Enum类实现了Comparable接口,因而可以进行枚举值间的比较,事实上就是索引值比较

    //返回两个枚举值的索引值之差
public final int compareTo(E o) {
return ordinal - ((Enum<?>) o).ordinal;
}

  enum还有两个操作应该是编译器调用Enum类的其他方法实现的。

  第一个是enum的values()方法,返回所有的类实例组成的数组,比如  enum Fruit {APPLE,ORANGE,GRAPE},就返回 new Fruit[]{Fruit.APPLE, Fruit.ORANGE, Fruit.GRAPE},这可以用于遍历操作。

for (Fruit f :Fruit.values()) {
....
}

  第二个是用switch做选择的时候,case后面只要写出枚举值即可,不必写类名

Fruit f = Fruit.APPLE;
switch(f) {
case (APPLE) { //此处不必也不能写成case (Fruit.APPLE),编译器自动判断这是Fruit类的实例
...
break;
}
case (ORANGE) {
...
break;
}
default {
...
}
}

  关于这是如何实现的,就是编译器自己的暗箱操作了,此处也不太清楚。

  另外,更高级一点的,就是把enum完全看成是一个class,因而可以重写自己的方法,添加自己的成员变量。例如用枚举值实现四则运算:

    public enum Operation {
//每个枚举值,即Operation实例,其实自己在声明时定义了一个匿名的类,继承了Operation类,匿名子类里面重写了父类Operation的apply方法
PLUS {double apply(double x,double y) {return x+y;}},
MINUS {double apply(double x,double y) {return x-y;}},
TIMES {double apply(double x,double y) {return x*y;}},
DIVIDE {double apply(double x,double y) {return x/y;}}; abstract double apply(double x, double y); //Operation类中定义的抽象方法
}

  上面的代码翻译过来其实是

    public class Operation extends Enum{

          public static final Operation PLUS = new Operation(){   //匿名内部类
@Override
double apply(double x,double y) {return x+y;}
};
...... abstract double apply(double x, double y); //Operation类中定义的抽象方法
}

  当然也可以自己实现enum,添加成员变量,重载构造函数

public enum Operation {

     PLUS("+"),     //等于:public static final Operation PLUS = new Operation("+");
MINUS("-"),
TIMES("*"),
DIVIDE("/"); private final String symbol; //自己加的成员变量 Operation(String symbol) {this.symbol = symbol;} //构造函数,在列枚举值的时候可以加括号给出参数,注意访问权限最好别写成public @Override
public String toString() {return symbol;} //重写Enum类的toString()方法
}

  最后,有一个小小的细节要注意,枚举值之间用“,”隔开。当enum定义中只有枚举值,没有其他东西时,枚举值最后可以不加“;”。但还有其他定义,比如还有一个成员方法,必须先写出枚举值,再加其他定义,且枚举值最后加“;”

    private enum Haha {

        private void f() {
System.out.println("!!!!!!!!!");
};
FACE,SUGAR,APPLE; //枚举值必须先写
}

枚举值的一大用处是用来替换零散的常量定义(public static final XXX XX = XX;),而且这些常量仅做标识符用,对于常量值是多少并不关心。使用了enum定义之后,可以进行类型检查,当常量很多时还可以归类,而且可以输出标识符的字面值。