Java编译期处理（语法糖）—— 编译器到底干了些什么？

编译期处理  ——  编译器到底干了些什么？

目录

编译期处理

1.1 语法糖 - 默认构造器

1.2 语法糖 - 自动拆装箱

1.3 语法糖 - 泛型擦除

1.4 语法糖 - 可变参数

1.5 语法糖 - foreach 循环

1.6 语法糖 - switch-string字符串

1.7 语法糖 - switch 枚举

1.8 语法糖 - 枚举类

1.9 语法糖 - try-with-resources

1.10 语法糖 - 重写桥接

1.11 语法糖 - 匿名内部类

所谓的语法糖，其实就是指 java 编译器所有  *.java 源码编译为  *.class 字节码的过程，自动生成和转换的一些代码， 主要是为了减轻程序员的负担，算是 java 编译器给我们的一个额外福利（给糖吃嘛）。

 

注意:  以下代码的分析，借助了 javap 工具，idea 的反编译功能，idea插件 jclasslib等工具。另外，编译器转换的结果直接就是 class字节码，只是为了便于阅读，给出了几乎等价的 java源码方式，并不是编译器还会转换出中间的 java源码，切记。

1.1 语法糖 - 默认构造器

先来看一下示例代码，里面没有自己声明构造方法：

  1. // 编译期处理(语法糖)——默认构造器
  2. public class T01_CompileTime_DefaultConstructor {
  3.     
  4. }

编译成 class 后的代码： 里面没有声明构造方法，无参构造是编译器帮助我们加上的。即调用父类 Object的无参构造方法：java/lang/Object.""方法

  1. // 编译期处理(语法糖)——默认构造器
  2. public class T01_CompileTime_DefaultConstructor {
  3.     // 这个无参构造是编译器帮助我们加止的
  4.     public T01_CompileTime_DefaultConstructor() {
  5.         super(); // 即调用父类 Object 的无参构造方法，即调用 java/lang/Object."":()V
  6.     }
  7. }

总结：

  1. 如果一个类中没有声明构造方法，无参构造是编译器会帮我们加上的。即调用父类 Object的无参构造方法：java/lang/Object.""方法 

1.2 语法糖 - 自动拆装箱

这个自动拆装箱特性是 JDK 5 开始加入的，代段片段1如下：

  1. // 编译期处理(语法糖)——自动拆装箱
  2. public class T02_CompileTime_AutoPackUnpack {
  3.     public static void main(String[] args) {
  4.         Integer x = 1;
  5.         int y = x;
  6.     }
  7. }

这段代码在 JDK 5 之前无法编译通过的，必须改写为 代码片段2：

  1. // 编译期处理(语法糖)——自动拆装箱
  2. public class T02_CompileTime_AutoPackUnpack {
  3.     public static void main(String[] args) {
  4.         Integer x = Integer.valueOf(1); // 装箱
  5.         int y = x.intValue; // 拆箱
  6.     }
  7. }

显然之前版本的代码太麻烦了，需要在基本类型和包装类型之间来回转换（尤其是集合类中操作的都是包装类型），因此这些转换的事情在 JDK 5 以后 装箱与拆箱操作 都由编译器在编译阶段完成，即 代码片段1 都会在编译阶段被转换为 代码片段2

总结：

  1. 自动拆装箱转换的事情在 JDK 5 以后 装箱与拆箱操作 都由编译器在编译阶段完成

1.3 语法糖 - 泛型擦除

泛型也是在 JDK 5 开始加入的特性，但 java 在编译泛型代码后会执行 泛型擦除 的动作，即泛型信息在编译为字节码之后果就丢失了，实际的类型都当做了 Object 类型来处理： 

  1. // 编译期处理(语法糖)——泛型擦除
  2. public class T03_CompileTime_GenericErase {
  3.     public static void main(String[] args) {
  4.         List list = new ArrayList<>();
  5.         list.add(10); // 实际调用的是 List.add(Object e)
  6.         Integer x = list.get(0); // 实际调用的是 Object obj = List.get(int index);
  7.     }
  8. }

所以在取值时，编译器真正生成的字节码中，还要额外做一个类型转换的操作：

  1. // 需要将 Object 转为 Integer
  2. Integer x = (Integer)list.get(0);

如果前面的 x 变量类型修改为 int 基本类型那么最终生成的字节码是：

  1. // 需要将 Object 转为 Integer，并执行拆箱操作
  2. int x = ((Integer)list.get(0)).intValue();

总结：

  1. 在JDK 5 及之后，泛型的类型转换麻烦事都不用自己做，java编译时就会帮我们做好。也就是说泛型参数只用于编译阶段的类型检查，不影响运行阶段
  2. 擦除的是字节码上的泛型信息，可以看到 LocalVariableTypeTable 仍然保留了方法参数泛型的信息

上述代码通过：javap -v T03_CompileTime_GenericErase.class进行反编译，得到如下字节码。

  1.   public static void main(java.lang.String[]);
  2.     descriptor: ([Ljava/lang/String;)V
  3.     flags: ACC_PUBLIC, ACC_STATIC
  4.     Code:
  5.       stack=2, locals=3, args_size=1
  6.          0: new           #2                  // class java/util/ArrayList
  7.          3: dup
  8.          4: invokespecial #3                  // Method java/util/ArrayList."":()V
  9.          7: astore_1
  10.          8: aload_1
  11.          9: bipush        10
  12.         11: invokestatic  #4                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
  13.         14: invokeinterface #5,  2            // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
  14.         19: pop
  15.         20: aload_1
  16.         21: iconst_0
  17.         22: invokeinterface #6,  2            // InterfaceMethod java/util/List.get:(I)Ljava/lang/Object;
  18.         27: checkcast     #7                  // class java/lang/Integer
  19.         30: astore_2
  20.         31: return
  21.       LineNumberTable: ...
  22.       LocalVariableTable:
  23.         Start  Length  Slot  Name   Signature
  24.             0      32     0  args   [Ljava/lang/String;
  25.             8      24     1  list   Ljava/util/List;
  26.            31       1     2     x   Ljava/lang/Integer;
  27.       LocalVariableTypeTable:
  28.         Start  Length  Slot  Name   Signature
  29.             8      24     1  list   Ljava/util/List;

1.4.1 语法糖 - 泛型反射

使用反射，仍然能够获得这些信息：

  1. public Set test(List list, Map map) {
  2. }
  1. Method test = T03_CompileTime_GenericErase.class.getMethod("test", List.class, Map.class);
  2. Type[] types = test.getGenericParameterTypes();
  3. for (Type type : types) {
  4.     if (type instanceof ParameterizedType) {
  5.         ParameterizedType parameterizedType = (ParameterizedType)type;
  6.         System.out.println("原始类型 - " + parameteredType.getRawType());
  7.         Type[] arguments = parameterizedType.getActualTypeArguments();
  8.         for (int i = 0; i < arguments.length; i++) {
  9.             System.out.printf("泛型参数[%d] - %s\n", i, arguments[i]);
  10.         }
  11.     }
  12. }

输出

  1. 原始类型 - interface java.util.List
  2. 泛型参数[0] - class java.lang.String
  3. 原始类型 - interface java.util.Map
  4. 泛型参数[0] - class java.lang.Integer
  5. 泛型参数[1] - class java.lang.Object

1.4 语法糖 - 可变参数

可变参数也是 JDK 5 开始加入的新特性，示例代码如下：

  1. // 编译期处理(语法糖)——可变参数
  2. public class T04_CompileTime_VariableParameter {
  3.     public static void foo(String... args) {
  4.         String[] array = args; // 直接赋值
  5.         System.out.println(array);
  6.     }
  7.  
  8.     public static void main(String[] args) {
  9.         foo("hello", "world");
  10.     }
  11. }

可变参数 String... args 其实是一个 String[] args，编译器会将可变参数转换为数组。从代码中赋值语句中就可以看出来。同样 java 编译器会在编译期间将上述代码变换为：

  1. // 编译期处理(语法糖)——可变参数
  2. public class T04_CompileTime_VariableParameter {
  3.     public static void foo(String[] args) { // 编译器将可变参数转换为数组
  4.         String[] array = args; // 直接赋值
  5.         System.out.println(array);
  6.     }
  7.  
  8.     public static void main(String[] args) {
  9.         foo("hello", "world");
  10.     }
  11. }

总结：

  1. 可变参数也是 JDK 5 开始加入的新特性；
  2. 可变参数 String... args 其实是一个 String[] args，编译器会将可变参数转换为数组；
  3. 如果调用了 foo() 则等价代码为 foo(new String[] {})，创建了一个空的数组，而不会传递 null 进去。

1.5 语法糖 - foreach 循环

仍是 JDK 5 开始引入的语法糖，数组的循环：

  1. // 编译期处理(语法糖)——foreach
  2. public class T05_CompileTime_Foreach {
  3.     public static void main(String[] args) {
  4.         int[] array = {1,2,3,4,5}; // 数组赋初值的简化写法也是语法糖哦
  5.         for (int e : array) {
  6.             System.out.println(e);
  7.         }
  8.     }
  9. }

foreach 循环会被编译器转换为 fori 循环：

  1. // 编译期处理(语法糖)——foreach
  2. public class T05_CompileTime_Foreach {
  3.     public T05_CompileTime_Foreach() {
  4.     }
  5.  
  6.     public static void main(String[] args) {
  7.         int[] array = new int[]{1,2,3,4,5}; 
  8.         for (int i = 0; i < array.length; i++) {
  9.             int e = array[i];
  10.             System.out.println(e);
  11.         }
  12.     }
  13. }

而集合的循环：

  1. // 编译期处理(语法糖)——foreach
  2. public class T05_CompileTime_Foreach {
  3.     public static void main(String[] args) {
  4.         List list = Arrays.asList(1,2,3,4,5);
  5.         for (Integer i : list) {
  6.             System.out.println(i);
  7.         }
  8.     }
  9. }

实际被编译器转换为对迭代器的调用：

  1. // 编译期处理(语法糖)——foreach
  2. public class T05_CompileTime_Foreach {
  3.     public T05_CompileTime_Foreach() {
  4.     }
  5.  
  6.     public static void main(String[] args) {
  7.         List list = Arrays.asList(1,2,3,4,5);
  8.         Iterator iter = list.iterator(); // 获取迭代器
  9.         while (iter.hasNext()) {
  10.             Integer e = (Integer)iter.next(); // 类型转换
  11.             System.out.println(e);
  12.         }
  13.     }
  14. }

总结：

  1. JDK 5 开始引入的语法糖
  2. 数组的循环 foreach 循环会被编译器转换为 fori 循环
  3. 集合的循环 实际被编译器转换为对迭代器的调用
  4. foreach 循环写法，能够配合数组，以及所有实现了 Iterable 接口的集合类一起使用，其中 Iterable 用来获取集合的迭代器 （Iterator）

1.6 语法糖 - switch-string字符串

从JDK 7 开始，switch 可以作用于字符串和枚举类，这个功能其实也是语法糖，例如：

  1. // 编译期处理(语法糖)——switch-string
  2. public class T06_CompileTime_SwitchString {
  3.     public static void choose(String str) {
  4.         switch (str) {
  5.             case "hello": {
  6.                 System.out.println("h");
  7.                 break;
  8.             }
  9.             case "world": {
  10.                 System.out.println("w");
  11.                 break;
  12.             }
  13.         }
  14.     }
  15. }

注意：

  1. switch 配合 String 和枚举使用时，变量不能为 null ，原因分析完语法糖转换后的代码应当自然清楚

会被编译器转换为：

  1. // 编译期处理(语法糖)——switch-string
  2. public class T06_CompileTime_SwitchString {
  3.     public T06_CompileTime_SwitchString() {
  4.  
  5.     }
  6.  
  7.     public static void choose(String str) {
  8.         byte x = -1;
  9.         switch (str.hashCode()) {
  10.             case 99162322: // hello 的 hashCode
  11.                 if (str.equals("hello")) {
  12.                     x = 0;
  13.                 }
  14.             case 113318802: // word 的 hashCode
  15.                 if (str.equals("world")) {
  16.                     x = 1;
  17.                 }
  18.         }
  19.         switch (x) {
  20.             case 0:
  21.                 System.out.println("h");
  22.                 break;
  23.             case 1:
  24.                 System.out.println("w");
  25.                 break;
  26.         }
  27.     }
  28. }

可以看到，执行了两遍 switch，第一遍是根据字符串的 hashCode 和 equals 将字符串的转换为相应的 byte 类型，第二遍才利用 byte 执行进行比较。

 

为什么第一遍时必须比较 hashCode ，又利用 equals 比较呢？hashCode 是为了提高效率，减少可能的比较；而 equals 是为了防止 hashCode 冲突，例如 BM 和 C. 这两个字符串的 hashCode 值都是 2123，如下代码：

  1. // 编译期处理(语法糖)——switch-string
  2. public class T06_CompileTime_SwitchString2 {
  3.     public static void choose(String str) {
  4.         switch (str) {
  5.             case "BM": {
  6.                 System.out.println("h");
  7.                 break;
  8.             }
  9.             case "C.": {
  10.                 System.out.println("w");
  11.                 break;
  12.             }
  13.         }
  14.     }

会被编译器转换为：

  1. // 编译期处理(语法糖)——switch-string
  2. public class T06_CompileTime_SwitchString2 {
  3.     public T06_CompileTime_SwitchString2() {
  4.  
  5.     }
  6.  
  7.     public static void choose(String str) {
  8.         byte x = -1;
  9.         switch (str.hashCode()) {
  10.             case 2123: // hashCode 值可能相同，需要进一步用 equals 比较
  11.                 if (str.equals("C.")) {
  12.                     x = 0;
  13.                 } else if (str.equals("BM")) {
  14.                     x = 1;
  15.                 }
  16.             default:
  17.                 switch (x) {
  18.                     case 0:
  19.                         System.out.println("h");
  20.                         break;
  21.                     case 1:
  22.                         System.out.println("w");
  23.                         break;
  24.                 }
  25.         }
  26.     }
  27. }

总结：

  1. switch-string字符串语法糖，从JDK 7 开始
  2. switch-string字符串，会java 编译器调整为执行了两遍 switch，第一遍是根据字符串的 hashCode 和 equals 将字符串的转换为相应的 byte 类型，第二遍才利用 byte 执行进行比较。 
  3. hashCode 是为了提高效率，减少可能的比较；而 equals 是为了防止 hashCode 冲突

1.7 语法糖 - switch 枚举

switch 枚举的例子，原始代码：

  1.     enum Sex {
  2.         MALE, FEMALE;
  3.     }
  1. // 编译期处理(语法糖)——switch-enum
  2. enum Sex {
  3.     MALE, FEMALE;
  4. }
  5.  
  6. public class T07_CompileTime_SwitchEnum {
  7.     public static void foo(Sex sex) {
  8.         switch (sex) {
  9.             case MALE:
  10.                 System.out.println("男"); break;
  11.             case FEMALE:
  12.                 System.out.println("女"); break;
  13.         }
  14.     }
  15. }

转换后代码：

  1. public class T07_CompileTime_SwitchEnum {
  2.     /**
  3.      * 定义一个合成类（仅 jvm 使用，对我们不可见）
  4.      * 用来映射枚举的 ordinal 与数组元素的关系
  5.      * 枚举的 ordinal 表示枚举对象的序号，从 0 开始
  6.      * 即 MALE 的 ordinal()=0, FEMALE 的 ordinal()=1
  7.      */
  8.     static class $MAP {
  9.         // 数组大小即为枚举元素个数，里面存储case用来对比的数字
  10.         static int[] map = new int[2];
  11.         static {
  12.             map[Sex.MALE.ordinal()] = 1;
  13.             map[Sex.FEMALE.ordinal()] = 2;
  14.         }
  15.     }
  16.  
  17.     public static void foo(Sex sex){
  18.         int x = $MAP.map[sex.ordinal()];
  19.         switch (x) {
  20.             case 1:{
  21.                 System.out.println("男");
  22.                 break;
  23.             }
  24.             case 2:{
  25.                 System.out.println("女");
  26.                 break;
  27.             }
  28.         }
  29.     }
  30. }

总结：

  1. 枚举类使用 switch 时，java编译器会帮我们自动合成一个静态类用来映射枚举的 ordinal 下标 与数组元素的关系，数组大小即为枚举元素个数，里面存储 case 是用来对比的数字；
  2. 接着，在 switch 方法中，取出枚举下标对应静态类中定义的数字，进行switch判断；

1.8 语法糖 - 枚举类

JDK 5 新增枚举类，以前面的性别的枚举为例：

  1. enum Sex {
  2.     MALE, FEMALE;
  3. }

java 编译器将上述转换后，得到如下代码：

  1. public final class Sex extends Enum {
  2.     public static final Sex MALE;
  3.     public static final Sex FEMALE;
  4.     private static final Sex[] $VALUES;
  5.  
  6.     static {
  7.         MALE = new Sex("MALE", 0);
  8.         FEMALE = new Sex("FEMALE", 1);
  9.         $VALUES = new Sex[]{MALE, FEMALE};
  10.     }
  11.     /**
  12.      * Sole constructor. Programmers cannot invoke this constructor.
  13.      * It is for use code emitted by the compiler in response to
  14.      * enum type declarations.
  15.      *
  16.      * @param name - The name of this enum constant, which is the identifier used to declare it.
  17.      * @param ordinal - The ordinal of this enumeration constant (its position in the enum declaration, where the initial constant is assigned
  18.      */
  19.     private Sex(String name, int ordinal) {
  20.         super(name, ordinal);
  21.     }
  22.  
  23.     public static Sex[] values() {
  24.         return $VALUES.clone();
  25.     }
  26.  
  27.     public static Sex valueOf(String name) {
  28.         return Enum.valueOf(Sex.class, name);
  29.     }
  30. }

总结：

  1. 枚举本质上是通过普通的类来实现的，只是编译器为我们进行了处理。每个枚举类型都继承自 java.lang.Enum，并自动添加了 values 和 valueOf 方法。而每个枚举常量是一个静态常量字段，使用内部类实现，该内部类继承了枚举类。所有枚举常量都通过静态代码块来进行初始化，即在类加载期间就初始化。另外通过把 clone、readObject、writeObject 这三个方法定义为 final 的，同时实现是抛出相应的异常。这样保证了每个枚举类型及枚举常量都是不可变的。可以利用枚举的这两个特性来实现线程安全的单例。

1.9 语法糖 - try-with-resources

JDK 7 开始新增了对需要关闭的资源处理的特殊语法 try-with-resources

  1. try (资源变量 = 创建资源对象) {
  2.  
  3. } catch {
  4.  
  5. }

其中资源对象需要实现 AutoCloseable 接口，例如：InputStream、OutputStream、Connection、Statement、ResultSet 等接口实现了 AutoCloseable，使用 try-with-resources 可以不用写 finally 语句块，编译器会帮助生成 finally 代码关闭资源，例如：

  1. // 编译期处理(语法糖) —— try-with-resources
  2. public class T09_CompileTime_TryWithResources {
  3.     public static void main(String[] args) {
  4.         try (InputStream is = new FileInputStream("in/1.txt")){
  5.             System.out.println(is);
  6.         } catch (IOException e) {
  7.             e.printStackTrace();
  8.         }
  9.     }
  10. }

java 编译器在编译时，会做如下改动：

  1. // 编译期处理(语法糖) —— try-with-resources
  2. public class T09_CompileTime_TryWithResources2 {
  3.     public T09_CompileTime_TryWithResources2() {
  4.  
  5.     }
  6.     public static void main(String[] args) {
  7.         try {
  8.             InputStream is = new FileInputStream("in/1.txt");
  9.             Throwable t  = null;
  10.             try {
  11.                 System.out.println(is);
  12.             } catch (Throwable e1) {
  13.                 // t 是我们代码出现的异常
  14.                 t = e1;
  15.                 throw e1;
  16.             } finally {
  17.                 // 判断了资源不为空
  18.                 if (is != null) {
  19.                     // 如果我们代码有异常
  20.                     if (t != null) {
  21.                         try {
  22.                             is.close();
  23.                         } catch (Throwable e2) {
  24.                             // 如果 close 出现异常，作为被压制异常添加; 这样异常不会丢
  25.                             t.addSuppressed(e2); // 一般开发人员不会考虑这么全面的异常捕获
  26.                         }
  27.                     } else {
  28.                         // 如果我们代码没有异常，close 出现的异常就是最后的 catch 块中的 e
  29.                         is.close();
  30.                     }
  31.                 }
  32.             }
  33.         } catch (IOException e) {
  34.             e.printStackTrace();
  35.         }
  36.     }
  37. }

 什么要设计一个 addSuppressed (Throwable e) （添加被压制异常）的方法呢？是为了防止异常信息的丢失（想想 try-with-resources 生成的 finally 中如果抛出了异常）：

  1. // 编译期处理(语法糖) —— try-with-resources
  2. public class T09_CompileTime_TryWithResources3 {
  3.     public static void main(String[] args) {
  4.         try (MyResource resource = new MyResource()) {
  5.             int i = 1/0;
  6.         } catch (Exception e){
  7.             e.printStackTrace();
  8.         }
  9.     }
  10.  
  11.     static class MyResource implements AutoCloseable {
  12.         //@Override
  13.         public void close() throws Exception {
  14.             throw new Exception("close 异常");
  15.         }
  16.     }
  17. }

如以上代码所示，两个异常信息都不会丢。 

总结：

  1. JDK 7 开始新增了对需要关闭的资源处理的特殊语法 try-with-resources
  2. 资源对象需要实现 AutoCloseable 接口，例如：InputStream、OutputStream、Connection、Statement、ResultSet 等接口实现了 AutoCloseable，使用 try-with-resources 可以不用写 finally 语句块，编译器会帮助生成 finally 代码关闭资源
  3. try-with-resources 能实现正常资源的关闭，如果出现了异常，异常信息不会丢失

1.10 语法糖 - 重写桥接

我们都知道，方法重写对对返回值分两种情况：

  • 父子类的返回值完全一致
  • 子类返回值可以是父类返回值的子类（比较绕口，见下面的例子）
  1. class A {
  2.     public Number m() {
  3.         return 1;
  4.     }
  5. }
  6.  
  7. class B extends A {
  8.     @Override
  9.     // 子类 m 方法的返回值是 Integer 是父类 m 方法返回值 Number 的子类
  10.     public Number m() {
  11.         return 2;
  12.     }
  13. }

对于子类，java编译器会做如下处理：

  1. class B extends A {
  2.     public Integer m() {
  3.         return 2;
  4.     }
  5.     // 此方法才是真正重写了父类 public Number m() 方法； synthetic bridge 是jvm合成的，对我们不可见
  6.     public synthetic bridge Number m() {
  7.         // 调用 public Integer m()
  8.         return m();
  9.     }
  10. }

其中桥接方法比较特殊，仅对 java 虚拟机可见，并且与原来的 public Integer m() 没有命名冲突，可以用下面反射代码来验证：

  1. for (Method m : B.class.getDeclaredMethods()) {
  2.     System.out.println(m);
  3. }

会输出：

  1. public java.lang.Integer test.candy.B.m()
  2. public java.lang.Number test.candy.B.m()

总结：

  1. 父类 A 的 m 的返回值是 Number 类型，子类 B 重写 m 返回的值是 Integer 类型，对于 Java 语言是重写的，但对于 Java 虚拟机解析来说却不是重写的，只有当两个方法的参数类型以及返回类型一致时，Java 虚拟机才会判定为重写，为了保持重写的语义，Java 编译器会在 B类 的字节码文件中自动生成一个桥接方法来保证重写语义。

1.11 语法糖 - 匿名内部类

先来看一下匿名内部类的示例：

  1. public class T11_Compile_HideInnerClass {
  2.     public static void main(String[] args) {
  3.         Runnable runnable = new Runnable() {
  4.             @Override
  5.             public void run() {
  6.                 System.out.println("ok");
  7.             }
  8.         };
  9.     }
  10. }

转换后代码：java 编译器会自动生成一个叫 xxx$1 的类，该类实现 Runnable 接口

  1. final class T11_Compile_HideInnerClass$1 implements Runnable {
  2.     T11_Compile_HideInnerClass$1() {
  3.     }
  4.  
  5.     public void run() {
  6.         System.out.println("ok")
  7.     }
  8. }

 然后在 xxx 类中，调用由 java 编译器自动生成的 xxx$1 类对象

  1. final class T11_Compile_HideInnerClass {
  2.     public static void main(String[] args) {
  3.         Runnable runnable = new T11_Compile_HideInnerClass$1();
  4.     }
  5. }

接下来，我们继续看另外一个例子：引用局部变量的匿名内部类，源代码：

  1. // 编译期处理(语法糖) —— 匿名内部类
  2. public class T11_Compile_HideInnerClass {
  3.     public static void test(final int x) {
  4.         Runnable runnable = new Runnable() {
  5.             @Override
  6.             public void run() {
  7.                 System.out.println("ok:" + x);
  8.             }
  9.         };
  10.     }
  11. }

java 编译器会自动生成一个叫 xxx$1的类，该类实现 Runnable 接口。如有存在引用局部变量，则会将局部变量 x 做为动态生成类 xxx$1 类的一个成员变量，通过构造方法传入。 转换后代码：

  1. final class T11_Compile_HideInnerClass$1 implements Runnable {
  2.     int val$x;
  3.     T11_Compile_HideInnerClass$1(int x) {
  4.         this.val$x = x;
  5.     }
  6.  
  7.     public void run() {
  8.         System.out.println("ok" + this.val$x)
  9.     }
  10. }
  1. final class T11_Compile_HideInnerClass {
  2.     public static void test(final int x) {
  3.         Runnable runnable = new T11_Compile_HideInnerClass$1(x);
  4.     }
  5. }

注意：

这同时解释了为什么匿名内部类引用局部变量时，局部变量必须是 final 的：因为在创建 xxx$1 对象时，将 x 的值赋值给了 xxx$1 对象的 val$x 属性，所以 x 不应该再发生变化了，如果变化，那 val$x 属性没有机会再跟着一起变化

 

总结：

  1. 匿名内部类的底层实现，由Java 编译器自动生成一个叫 xxx$1的类，该类实现 Runnable 接口。如果存在引用局部变量，则会将局部变量 x 做为动态生成类 xxx$1 类的一个成员变量，通过构造方法传入。
  2. 局部变量必须是 final 的：因为在创建 xxx$1 对象时，将 x 的值赋值给了 xxx$1 对象的 val$x 属性，所以 x 不应该再发生变化了，如果变化，那 val$x 属性没有机会再跟着一起变化

 

文章最后，给大家推荐一些受欢迎的技术博客链接：

  1. Hadoop相关技术博客链接
  2. Spark 核心技术链接
  3. JAVA相关的深度技术博客链接
  4. 超全干货--Flink思维导图，花了3周左右编写、校对
  5. 深入JAVA 的JVM核心原理解决线上各种故障【附案例】
  6. 请谈谈你对volatile的理解？--最近小李子与面试官的一场“硬核较量”
  7. 聊聊RPC通信，经常被问到的一道面试题。源码+笔记，包懂

 

欢迎扫描下方的二维码或 搜索 公众号“10点进修”，我们会有更多、且及时的资料推送给您，欢迎多多交流！

                                           

       

注：本文转载自blog.csdn.net的不埋雷的探长的文章"https://blog.csdn.net/weixin_32265569/article/details/108031637"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！