通过反编译字节码来理解 Java Enum

最新推荐文章于 2024-07-22 16:43:43 发布
最新推荐文章于 2024-07-22 16:43:43 发布
阅读量1.5k 收藏 1
点赞数 1
分类专栏： Java 文章标签： enum java

枚举的声明很简单, 像 enum Gender { Male, Female }, 其余事情就是 Java 编译器帮我们干的了，所以 enum 也就是一块语法糖。有了枚举确实是很方便，避免了传统常量的无范围性。那么编译器到底在后面做了什么呢？以及理解了这个之后我们可以怎么去使用 Java 的枚举, 下面就从这个例子说起：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public enum Gender {  
  2.     Male,  
  3.     Female  
  4. }  
public enum Gender {
    Male,
    Female
}

把上面的编译成 Gender.class, 然后用  javap -c Gender 反编译出来就是

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public final class Gender extends java.lang.Enum {  
  2.   public static final Gender Male;  
  3.    
  4.   public static final Gender Female;  
  5.    
  6.   public static Gender[] values();  
  7.     Code:  
  8.        0: getstatic     #1                  // Field $VALUES:[LGender;  
  9.        3: invokevirtual #2                  // Method "[LGender;".clone:()Ljava/lang/Object;  
  10.        6: checkcast     #3                  // class "[LGender;"  
  11.        9: areturn  
  12.    
  13.   public static Gender valueOf(java.lang.String);  
  14.     Code:  
  15.        0: ldc_w         #4                  // class Gender  
  16.        3: aload_0  
  17.        4: invokestatic  #5                  // Method java/lang/Enum.valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;  
  18.        7: checkcast     #4                  // class Gender  
  19.       10: areturn  
  20.    
  21.   static {};  
  22.     Code:  
  23.        0: new           #4                  // class Gender  
  24.        3: dup  
  25.        4: ldc           #7                  // String Male  
  26.        6: iconst_0  
  27.        7: invokespecial #8                  // Method "":(Ljava/lang/String;I)V  
  28.       10: putstatic     #9                  // Field Male:LGender;  
  29.       13: new           #4                  // class Gender  
  30.       16: dup  
  31.       17: ldc           #10                 // String Female  
  32.       19: iconst_1  
  33.       20: invokespecial #8                  // Method "":(Ljava/lang/String;I)V  
  34.       23: putstatic     #11                 // Field Female:LGender;  
  35.       26: iconst_2  
  36.       27: anewarray     #4                  // class Gender  
  37.       30: dup  
  38.       31: iconst_0  
  39.       32: getstatic     #9                  // Field Male:LGender;  
  40.       35: aastore  
  41.       36: dup  
  42.       37: iconst_1  
  43.       38: getstatic     #11                 // Field Female:LGender;  
  44.       41: aastore  
  45.       42: putstatic     #1                  // Field $VALUES:[LGender;  
  46.       45: return  
  47. }  
public final class Gender extends java.lang.Enum {
  public static final Gender Male;
 
  public static final Gender Female;
 
  public static Gender[] values();
    Code:
       0: getstatic     #1                  // Field $VALUES:[LGender;
       3: invokevirtual #2                  // Method "[LGender;".clone:()Ljava/lang/Object;
       6: checkcast     #3                  // class "[LGender;"
       9: areturn
 
  public static Gender valueOf(java.lang.String);
    Code:
       0: ldc_w         #4                  // class Gender
       3: aload_0
       4: invokestatic  #5                  // Method java/lang/Enum.valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
       7: checkcast     #4                  // class Gender
      10: areturn
 
  static {};
    Code:
       0: new           #4                  // class Gender
       3: dup
       4: ldc           #7                  // String Male
       6: iconst_0
       7: invokespecial #8                  // Method "":(Ljava/lang/String;I)V
      10: putstatic     #9                  // Field Male:LGender;
      13: new           #4                  // class Gender
      16: dup
      17: ldc           #10                 // String Female
      19: iconst_1
      20: invokespecial #8                  // Method "":(Ljava/lang/String;I)V
      23: putstatic     #11                 // Field Female:LGender;
      26: iconst_2
      27: anewarray     #4                  // class Gender
      30: dup
      31: iconst_0
      32: getstatic     #9                  // Field Male:LGender;
      35: aastore
      36: dup
      37: iconst_1
      38: getstatic     #11                 // Field Female:LGender;
      41: aastore
      42: putstatic     #1                  // Field $VALUES:[LGender;
      45: return
}

从上面的字节码能够粗略的知道以下几点

  1. Gender 是 final 的
  2. Gender 继承自 java.lang.Enum 类
  3. 声明了字段对应的两个 static final Gender 的实例
  4. 实现了 values() 和  valueOf(String) 静态方法
  5. static{} 对所有成员进行初始化

有了以上的字节码，我们作进一步还原出 Gender 的普通类大概是这样的：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public final class Gender extends java.lang.Enum {  
  2.    
  3.   public static final Gender Male;  
  4.   public static final Gender Female;  
  5.    
  6.   private static final Gender[] $VALUES;  
  7.    
  8.   static {  
  9.     Male = new Gender("Male", 0);  
  10.     Female = new Gender("Female", 1);  
  11.    
  12.     $VALUES = new Gender[] {Male, Female};  
  13.   }  
  14.    
  15.   private Gender(String name, int original) {  
  16.     super(name, original)  
  17.   }  
  18.    
  19.   public static Gender[] values() {  
  20.     return $VALUE.clone();  
  21.   }  
  22.    
  23.   public static Gender valueOf(String name) {  
  24.     return Enum.valueOf(Gender.class, name);  
  25.   }  
  26. }  
public final class Gender extends java.lang.Enum {
 
  public static final Gender Male;
  public static final Gender Female;
 
  private static final Gender[] $VALUES;
 
  static {
    Male = new Gender("Male", 0);
    Female = new Gender("Female", 1);
 
    $VALUES = new Gender[] {Male, Female};
  }
 
  private Gender(String name, int original) {
    super(name, original)
  }
 
  public static Gender[] values() {
    return $VALUE.clone();
  }
 
  public static Gender valueOf(String name) {
    return Enum.valueOf(Gender.class, name);
  }
}

private Gender(String name, int origianl) 是我加上去的，是为了模拟枚举实例的创建，其实实例都是在 static 块中创建的。

当然上面的那个类是无法被编译的，因为 Java  编译器限制了我们显式的继承自 java.Lang.Enum 类, 报错 "The type Gender may not subclass Enum explicitly", 虽然 java.Lang.Enum 声明的是

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public abstract class Enum>  
  2.         implements Comparable, Serializable  
public abstract class Enum>
        implements Comparable, Serializable

这样看来枚举类其实用了多例模式，枚举类的实例是有范围限制的。它同样像我们的传统常量类，只是它的元素是有限的枚举类本身的实例。它继承自 java.lang.Enum, 所以可以直接调用 java.lang.Enum 的方法，如 name(), original() 等，name 就是常量名称, original 与 C 的枚举一样的编号。

可以在枚举类中自定义构造方法，但必须是  private 或  package protected, 因为枚举本质上是不允许在外面用 new Gender() 方式来构造实例的(Cannot instantiate the type Gender)，否则也是要乱了套的。

我们可以在枚举中定义自己的类，或实例方法，比如对于   enum Gender, 方法会直接定义给  Gender 类或实例上去。

由于 enum 隐式继承自 java.lang.Enum 类，且 Java 不接受类的多重继承，所以我们不能让 enum 再继承别的类，下面那样写是错误的

enum Gender extends Security {} //Syntax error on token "extends", implements expected

不能类多重继承，那枚举可以实现接口啊，因此下面的写法是正确的

public enum Gender implements Behavior {}


让枚举实现接口有时候可以让设计变得巧妙。

结合枚举实现接口以及自定义方法，可以写出下面那样的代码：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. interface Behavior {  
  2.   void print();  
  3. }  
  4.    
  5. public enum Gender implements Behavior {  
  6.   Male {  
  7.     @Override  
  8.     public void print() {  
  9.       System.out.println("Male special behavior");  
  10.     }  
  11.   },  
  12.   Female;  
  13.      
  14.   @Override  
  15.   public void print() {  
  16.     System.out.println("Common behavior");  
  17.   }  
  18.      
  19.   public static void main(String[] args) {  
  20.     Gender.Male.print(); //Male special behavior  
  21.     Gender.Female.print();  //Common behavior  
  22.   }  
  23. }  
interface Behavior {
  void print();
}
 
public enum Gender implements Behavior {
  Male {
    @Override
    public void print() {
      System.out.println("Male special behavior");
    }
  },
  Female;
   
  @Override
  public void print() {
    System.out.println("Common behavior");
  }
   
  public static void main(String[] args) {
    Gender.Male.print(); //Male special behavior
    Gender.Female.print();  //Common behavior
  }
}

方法可以定义成所有实例公有，也可以让个别元素独有。

需要特别注明一下，上面在 Male {} 声明一个 print() 方法后实际产生一个 Gender 的匿名子类，编译后的 Gender$1，反编译它 javap -c Gender\$1：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. final class Gender$1 extends Gender {  
  2.   Gender$1(java.lang.String, int);  
  3.     Code:  
  4.        0: aload_0  
  5.        1: aload_1  
  6.        2: iload_2  
  7.        3: aconst_null  
  8.        4: invokespecial #1                  // Method Gender."":(Ljava/lang/String;ILGender$1;)V  
  9.        7: return  
  10.    
  11.   public void print();  
  12.     Code:  
  13.        0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;  
  14.        3: ldc           #3                  // String Male special behavior  
  15.        5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V  
  16.        8: return  
  17. }  
final class Gender$1 extends Gender {
  Gender$1(java.lang.String, int);
    Code:
       0: aload_0
       1: aload_1
       2: iload_2
       3: aconst_null
       4: invokespecial #1                  // Method Gender."":(Ljava/lang/String;ILGender$1;)V
       7: return
 
  public void print();
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #3                  // String Male special behavior
       5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return
}

所以在 emum Gender 那个枚举中的成员  Male 相当于是

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public static final Male = new Gender$1("Male", 0); //而不是 new Gender("Male", 0)  
public static final Male = new Gender$1("Male", 0); //而不是 new Gender("Male", 0)

上面 4: Invokespecial #1 要调用到下面的 Gender(java.lang.String, int, Gender$1) 方法。

若要研究完整的 Male 元素的初始化过程就得 javap -c Gender 看 Gender.java 产生的所有字节码，在此列出片断

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. Gender(java.lang.String, int, Gender$1);  
  2.     Code:  
  3.        0: aload_0  
  4.        1: aload_1  
  5.        2: iload_2  
  6.        3: invokespecial #1                  // Method "":(Ljava/lang/String;I)V  
  7.        6: return  
  8.    
  9.   static {};  
  10.     Code:  
  11.        0: new           #14                 // class Gender$1  
  12.        3: dup  
  13.        4: ldc           #15                 // String Male  
  14.        6: iconst_0  
  15.        7: invokespecial #16                 // Method Gender$1."":(Ljava/lang/String;I)V  
  16.       10: putstatic     #11                 // Field Male:LGender;  
Gender(java.lang.String, int, Gender$1);
    Code:
       0: aload_0
       1: aload_1
       2: iload_2
       3: invokespecial #1                  // Method "":(Ljava/lang/String;I)V
       6: return
 
  static {};
    Code:
       0: new           #14                 // class Gender$1
       3: dup
       4: ldc           #15                 // String Male
       6: iconst_0
       7: invokespecial #16                 // Method Gender$1."":(Ljava/lang/String;I)V
      10: putstatic     #11                 // Field Male:LGender;


在 static{} 中大致看下 Male 的初始过程：加载 Gender$1, 并调用它的 Gender$1(java.lang.String, int) 构造函数生成一个 Gender$1 实例赋给 Male 属性。

JDK 提供有两个关于枚举的工具类  EnumSet 和 EnumMap,  实际中可以好好发掘发掘一下

零度anngle
关注
专栏目录
java 反编译 枚举类
qq_35356190的博客
10-03 865
目录 一、Java枚举类源代码 二、编译 三、简单反编译 1.命令 2.反编译结果 四、复杂反编译 1.命令 2.结果 五、Enum 源码 一、Java枚举类源代码 package com.fanzs.enums; public enum DateTypeEnum { YEAR, MONTH, DAY; } 二、编译 javac DateTypeEnum.java 三、简单反编译 1.命令 javap -p DateTypeEnum.class 2.反编译结
JVM笔记：Java虚拟机的字节码指令详解
verzqli的博客
10-29 1023
1.字节码 Java能发展到现在，其“一次编译，多处运行”的功能功不可没，这里最主要的功劳就是JVM和字节码了，在不同平台和操作系统上根据JVM规范的定制JVM可以运行相同字节码（.Class文件），并得到相同的结果。之所以被称之为字节码，是因为字节码文件由十六进制值组成，而JVM以两个十六进制值为一组，即以字节为单位进行读取。在Java中一般是用javac命令编译源代码为字节码文件，将java...
通过反编译字节码来理解 Java 枚举
z69183787的专栏
01-06 2028
枚举的声明很简单, 像 enum Gender { Male, Female }, 其余事情就是 Java 编译器帮我们干的了，所以 enum 也就是一块语法糖。有了枚举确实是很方便，避免了传统常量的无范围性。那么编译器到底在后面做了什么呢？以及理解了这个之后我们可以怎么去使用 Java 的枚举, 下面就从这个例子说起： public enum Gender {     Male,
掌握 Java 字节码的基本操作指令（反汇编字节码）
最新发布
weixin_44711513的博客
07-22 1098
JVM（Java虚拟机）对每个字节码指令都有特定的含义。字节码是JVM理解和执行的机器语言，JVM通过解析和执行这些字节码指令来运行Java程序。每个字节码指令都有一个操作码（opcode），操作码定义了特定的操作，以及操作所需的操作数，对应上述其中某些字节码，比如。
使用javap进行反编译Java枚举
weixin_30739595的博客
12-28 129
这是一个枚举类Day.java public enum Day { MONDAY("星期一"), TUESDAY("星期二"), WEDNESDAY("星期三"), THURSDAY("星期四"), FRIDAY("星期五"), SATURDAY("星期六"), SUNDAY("星期天"); /** ...
enum的反编译
水墨青花的专栏
07-26 2042
源码： public enum Type { SELECT, UPDATE, INSERT, DELETE }; 反编译后： public static final class Type extends Enum { public static final Type SELECT; public static final T
Java中的语法糖及反编译工具
居易
04-02 752
雪压枝头低，虽低不着泥壹·Java中的反编译工具贰·常见的12“颗”语法糖switchforEach 语法糖（Syntactic Sugar），也称糖衣语法，指在计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。简而言之，语法糖让程序更加简洁，有更高的可读性。 但其实看过《深入理解Java虚拟机》或者了解过JVM的同学都知道，Java虚拟机并不支持这些语法糖，这些语法糖在编译阶段就会被还原成基本语法结构。 还是那句话，编程语言的每个语法背后都有它深层次的含义，即便是因为“懒”
从一个基本的类的反编译说起让你读懂Java字节码文件
weixin_42478164的博客
09-05 1440
从一个基本的类的反编译说起让你读懂Java字节码文件
java 枚举 动态_Java动态修改Enum实例
weixin_39594191的博客
02-12 774
众所周知，enum类型实例数量是固定的，甚至还被用来设计单例。但有时候仍然存在需要动态增加Enum实例的场景，这也并非一定是设计失败，也可能是增加灵活性的实际需求，比如一些web框架，再比如HanLP中的动态用户自定义词性。然而最大的障碍是switch语句生成的虚构类，本文参考Java Specialists第161期，提供一份可用的解决方案与实例代码。一段有问题的代码比如我们有一个enum类...
python反编译_反编译 python
weixin_39887546的博客
11-30 1245
广告关闭腾讯云11.11云上盛惠 ，精选热门产品助力上云，云服务器首年88元起，买的越多返的越多，最高返5000元！我正在尝试使用idapython在rdapro中执行这个python脚本。 https:github.comeinstein-ida-decompiler 它说要运行这个脚本，只需执行以下操作：这是一个ida插件，可以一次解压缩一个函数。 要在ida中试用它，请将光标放在函数上，然后...
JAVA可以反编译枚举的反编译工具
01-17
JAVA反编译工具
通过反编译深入理解Java枚举类型
離陸する的博客
03-11 883
文章目录通过反编译深入理解Java枚举类型1.枚举类底层原理1.1简单枚举类反编译-javap反编译-CRF1.2自定义枚举类1.3枚举类的其他特性2.switch对枚举支持原理 通过反编译深入理解Java枚举类型 1.枚举类底层原理 1.1简单枚举类 public enum Season { /** * 枚举类测试 */ SPRING, SUMMER, FALL, WINTER } 反编译-javap 先用javap反编译一下(注意不带-c参数)，看看编译器生成的枚
通过字节码深入分析java的枚举类型enum
qq838642798的博客
07-23 730
1.      Java中的枚举究竟是什么鬼？ 如果从C++转java的话，会发现一个现象那就是在java中的枚举跟C++区别非常大，甚至可以说除了名字一样外，其他实现等都是非常不同的，在C++枚举更像个常数，而java的枚举更靠近正常的普通成员内部类。让我们从字节码角度看看java中的enum究竟是什么东西吧 源码：     public enum book{         BOO
【java 基础】枚举深思之反编译枚举类，验证枚举实现单例是线程安全的
李光 未来科技
01-14 335
1、
深入java 通过反编译看枚举用法
yabay2208的博客
09-14 4037
这篇文章总结java1.5后jdk中新加的一种类型：enum。更多的源代码请访问我的github：https://github.com/yangsheng20080808/deepIntoJava本文分为1大部分 反编译看枚举怎么用 其实枚举用法很简单 反编译看枚举怎么用枚举是基于泛型实现的，枚举是什么，其实枚举就是一个普通的类：enum是一个语法糖，Enum是对应的类： 我们将源代码先编译，然后
Java：从字节码看Enum类型
bdmh的专栏
09-27 417
从以上字节码我们看到，它会为每个枚举值创建一个对象，保留名字和对应的值，还要创建一个数组来保存所有的枚举，相比一个int类型的数值来说，确实比较占用内存。枚举类型对于我们访问非常的方便和清晰，但是却有很多同学是不建议多多地使用枚举类型，原因就是枚举类型还是比较占用内存的。接下来我们看static这段，这是初始化的工作，大概的流程就是调用Enum的构造方法，创建数组，保存三个枚举值，具体看注释吧。然后就是，我们定义的one，two，three三个枚举属性，在这里也看到了，分别定义为Test类型。
【语言篇】Java枚举类，字节码层面的深入浅出
grandachn的博客
11-05 1890
Java语言篇Java枚举类枚举类的作用枚举类的工程实践枚举类字节码分析 Java枚举类 关于Java枚举类的博文有很多，但是很多都是说怎么去用枚举，少有全面地把枚举类给将清楚的。本文将从枚举类的作用说起，到个人对枚举类的一些工程实践，然后从字节码去剖析枚举类的本质，介绍枚举类name和ordinal，EnumSet和EnumMap枚举集合类为何物，最后涉及枚举在单例模式和职责链模式中的应用。 （...
java枚举类初探-语法糖-反编译
ChenXi的博客
09-04 1265
java枚举类-语法糖-反编译 最近接触了“语法糖”这个概念，今天又看了一下枚举类的知识点，主要还是看它的用法，之前一直没有怎么用过java枚举类，看了李刚那本《疯狂java讲义》的枚举类章节，算是把它的用法弄明白了。 可是枚举类是一种“语法糖”，也就是说只有编译器知道“enum”关键字，jvm是不知道的，字节码文件中没有枚举这一概念。实际上，书中一开头就提到了在枚举出现前，程序员需要自己编程
深入理解Java枚举enum
"Java枚举（enum）是Java语言中的一种特殊类，用于定义一组相关的固定值。这个学习资料详细介绍了枚举的基本语法、特点以及常见的方法，非常适合初学者进行学习。通过枚举，我们可以更好地表示有限集合的值，增强...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值