疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

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定义之后,可以进行类型检查,当常量很多时还可以归类,而且可以输出标识符的字面值。