【JVM】-- Java编译期处理

我就是我 2023-07-06 14:34 13阅读 0赞

### 文章目录 ###

*   *  1.默认构造器
     *  2.自动拆装箱
     *  3.泛型与类型擦除
     *  4.可变参数
     *  5.foreach
     *  6.switch支持case使用字符串及枚举类型
     *   *  switch字符串
         *  switch枚举
     *  7.枚举
     *  8.try-with-resourcs
     *  9.方法重写时的桥接方法
     *  10.匿名内部类

编译器处理就是指 java 编译器把 \*.java 源码编译为 \*.class 字节码的过程中，自动生成和转换的一些代码，主要是为了减轻程序员的负担，算是 java 编译器给我们的一个额外福利，故·称之为语法糖（给糖吃嘛）。

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

## 1.默认构造器 ##

public class Candy1 { 
    }

经过编译的代码,可以看到在编译阶段，如果我们没有添加构造器。那么Java编译器会为我们添加一个无参构造方法。

public class Candy1 { 
        // 这个无参构造是编译器帮助我们加上的
        public Candy1() { 
          super(); // 即调用父类 Object 的无参构造方法，即调用 java/lang/Object."<init>":()V
        }
    }

## 2.自动拆装箱 ##

在JDK5以后，Java提供了自动拆装箱的功能。

如以下代码：

public class Candy2 { 
        public static void main(String[] args) { 
            Integer x = 1;
            int y = x;
        }
    }

在Java5以前会编译失败，必须该写为以下代码：

public class Candy2 { 
        public static void main(String[] args) { 
            Integer x = Integer.valueOf(1);
            int y = x.intValue();
        }
    }

以上的转换，在JDK5以后都会由Java编译器自动完成。

## 3.泛型与类型擦除 ##

泛型延时在JDK5以后加入的特性，但Java中的泛型并不是真正的泛型。因为Java中的泛型只存在于Java的源码中，在经过编译的字节码文件中,就已经替换为原来的原生类型(RawType,也称为裸类型,可以认为是被Object替换)了，并且在相应的地方插入了强制转型代码,因此,对于运行期的Java语言来说, ArrayList < int>与ArrayList< String>就是同一个类,所以泛型技术实际上是Java语言的一颗语法糖,Java语言中的泛型实现方法称为类型擦除，基于这种方法实现的泛型称为伪泛型。

如以下代码：

public class Candy3 { 
        public static void main(String[] args) { 
            List<Integer> list = new ArrayList<>();
            list.add(10); // 实际调用的是 List.add(Object e)
            Integer x = list.get(0); // 实际调用的是 Object obj = List.get(int index);
        }
    }

在从list集合中取值时，在编译器真正的字节码文件中还需要一个类型转换的动作

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

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

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

不过因为语法糖的存在，所以以上的动作都不需要我们自己来做。  
不过，虽然编译器在编译过程中，将泛型信息都擦除了，但是并不意味着，泛型信息就丢失了。泛型的信息还是会存储在LocalVariableTypeTable 中：

{ 
      public wf.Candy3();
        descriptor: ()V
        flags: ACC_PUBLIC
        Code:
          stack=1, locals=1, args_size=1
             0: aload_0
             1: invokespecial #1                  // Method java/lang/Object."<init>":()V
             4: return
          LineNumberTable:
            line 6: 0
          LocalVariableTable:
            Start  Length  Slot  Name   Signature
                0       5     0  this   Lwf/Candy3;
    
    
      public static void main(java.lang.String[]);
        descriptor: ([Ljava/lang/String;)V
        flags: ACC_PUBLIC, ACC_STATIC
        Code:
          stack=2, locals=3, args_size=1
             0: new           #2                  // class java/util/ArrayList
             3: dup
             4: invokespecial #3                  // Method java/util/ArrayList."<init>":()V
             7: astore_1
             8: aload_1
             9: bipush        10
            11: invokestatic  #4                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
            14: invokeinterface #5,  2            // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
            19: pop
            20: aload_1
            21: iconst_0
            22: invokeinterface #6,  2            // InterfaceMethod java/util/List.get:(I)Ljava/lang/Object;
            27: checkcast     #7                  // class java/lang/Integer
            30: astore_2
            31: return
          LineNumberTable:
            line 8: 0
            line 9: 8
            line 10: 20
            line 11: 31
          LocalVariableTable:
            Start  Length  Slot  Name   Signature
                0      32     0  args   [Ljava/lang/String;
                8      24     1  list   Ljava/util/List;
               31       1     2     x   Ljava/lang/Integer;
          LocalVariableTypeTable:
            Start  Length  Slot  Name   Signature
                8      24     1  list  Ljava/util/List<Ljava/lang/Integer;>;
    }
    SourceFile: "Candy3.java"

我们可以通过反射的方式获得被擦除的泛型信息。不过只能获取方法参数或返回值上的信息。

public class Candy3 { 
    
        List<String> str = new ArrayList<>();
    
        public static void main(String[] args) throws Exception { 
            List<Integer> list = new ArrayList<>();
            list.add(10); // 实际调用的是 List.add(Object e)
            Integer x = list.get(0); // 实际调用的是 Object obj = List.get(int index);
            fs();
        }
        public Set<Integer> test(List<String> list, Map<Integer, Object> map) { 
            return null;
        }
    
        private static void fs() throws Exception { 
            Method test = Candy3.class.getMethod("test", List.class, Map.class);
            Type[] types = test.getGenericParameterTypes();
            for (Type type : types) { 
                if (type instanceof ParameterizedType) { 
                    ParameterizedType parameterizedType = (ParameterizedType) type;
                    System.out.println("原始类型 - " + parameterizedType.getRawType());
                    Type[] arguments = parameterizedType.getActualTypeArguments();
                    for (int i = 0; i < arguments.length; i++) { 
                        System.out.printf("泛型参数[%d] - %s\n", i, arguments[i]);
                    }
                }
            }
    
            Field list = Candy3.class.getDeclaredField("str");
            Class<?> type = list.getType();
            System.out.println(type.getName());
        }
    }

输出：

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

## 4.可变参数 ##

可变参数也是JDK5新加入的特性。其具体形式如下：

public class Test3 { 
    
        public static void main(String[] args) { 
            foo("hello","world");
        }
    
        private static void foo(String... args){ 
            String[] str = args;
            for (int i = 0; i < str.length; i++) { 
                System.out.println(str[i]);
            }
        }
    }

其结果由一个字符串数组直接接受，程序能够正常执行。  
**注意：如果调用方法时没有参数如foo(),那么传入方法的不是null，而是一个空数组foo(new String\[\]\{\})。**

## 5.foreach ##

依旧是JDK5引入的语法糖。简化了for循环的写法。

示例：

public class Test4_1 { 
    
        public static void main(String[] args) { 
            int[] arr = { 1,2,3,4,5};
            for (int i : arr) { 
                System.out.print(" " + i);
            }
        }
    }

在对其字节码反编译后：

public class Test4_1 { 
        public Test4_1() { 
        }
    
        public static void main(String[] args) { 
            int[] arr = new int[]{ 1, 2, 3, 4, 5};
            int[] var2 = arr;
            int var3 = arr.length;
    
            for(int var4 = 0; var4 < var3; ++var4) { 
                int i = var2[var4];
                System.out.print(" " + i);
            }
        }
    }

此处包含两个语法糖

*  \{1,2,3,4,5\}转为数组才进行复制
 *  foreach循环被转换为了简单的for循环。

foreach循环还可以对集合进行遍历：

public class Test4_2 { 
    
        public static void main(String[] args) { 
            List<Integer> list = Arrays.asList(1,2,3,4,5);
    
            for (Integer integer : list) { 
                System.out.print(integer + " ");
            }
        }
    }

其编译后字节码的反编译出的代码为：

public class Test4_2 { 
        public Test4_2() { 
        }
    
        public static void main(String[] args) { 
            List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
            Iterator var2 = list.iterator();
    
            while(var2.hasNext()) { 
                Integer integer = (Integer)var2.next();
                System.out.print(integer + " ");
            }
        }
    }

编译器先获取集合的迭代器对象，在通过while循环对迭代器对象进行遍历。其中还包含泛型擦除的语法糖。  
foreach循环写法，配合数组，及实现了Iterable接口的集合类使用，Iterable来获取迭代器对象（Iterator）

## 6.switch支持case使用字符串及枚举类型 ##

JDK7开始，Java的switch支持字符串和枚举类型，而其中也包含了语法糖。

### switch字符串 ###

示例：

public class Test5_1 { 
    
        public static void main(String[] args) { 
            switch ("hello"){ 
                case "hello":
                    System.out.println("hello");
                    break;
                case "world":
                    System.out.println("world");
            }
        }
    }

注意：在使用String时，不能传入一个null，会发生空指针异常。因为以上代码会被编译器转换为：

public class Test5_1 { 
        public Test5_1() { 
        }
    
        public static void main(String[] args) { 
            String var1 = "hello";
            byte var2 = -1;
            switch(var1.hashCode()) { 
            case 99162322:
                if (var1.equals("hello")) { 
                    var2 = 0;
                }
                break;
            case 113318802:
                if (var1.equals("world")) { 
                    var2 = 1;
                }
            }
    
            switch(var2) { 
            case 0:
                System.out.println("hello");
                break;
            case 1:
                System.out.println("world");
            }
    
        }
    }

可以看到，switch支持字符实际上是把对象，获取其哈希值进行一次比较在确定了，之后再用一个switch来实现代码逻辑。  
为什么第一次既要进行一次哈希比较，又要进行一次equals(）?使用hashcode是为了提高比较的效率，而equals是为了防止哈希冲突。如BM和C.两个字符串的哈希值相同都为2123，如果有以下代码：

public class Test5_2 { 
    
        public static void main(String[] args) { 
            switch ("BM"){ 
                case "BM":
                    System.out.println("hello");
                    break;
                case "C.":
                    System.out.println("world");
            }
        }
    }

经过反编译后：

public class Test5_2 { 
        public Test5_2() { 
        }
    
        public static void main(String[] args) { 
            String var1 = "BM";
            byte var2 = -1;
            switch(var1.hashCode()) { 
            case 2123://哈希值相同需要进一步比较
                if (var1.equals("C.")) { 
                    var2 = 1;
                } else if (var1.equals("BM")) { 
                    var2 = 0;
                }
            default:
                switch(var2) { 
                case 0:
                    System.out.println("hello");
                    break;
                case 1:
                    System.out.println("world");
                }
    
            }
        }
    }

### switch枚举 ###

代码如下：

public class Test5_3 { 
    
        public static void main(String[] args) { 
            Sex sex = Sex.MALE;
    
            switch (sex){ 
                case MALE:
                    System.out.println("男");
                    break;
                case FEMALE:
                    System.out.println("女");
            }
        }
    }
    
    enum Sex{ 
        MALE,FEMALE;
    }

转换后：

/** * 定义一个合成类（仅 jvm 使用，对我们不可见） * 用来映射枚举的 ordinal 与数组元素的关系 * 枚举的 ordinal 表示枚举对象的序号，从 0 开始 * 即 MALE 的 ordinal()=0，FEMALE 的 ordinal()=1 * 该转换需要使用其他工具进行转换，idea转换不出来 */
    static class $MAP { 
    // 数组大小即为枚举元素个数，里面存储case用来对比的数字
        static int[] map = new int[2];
        static { 
            map[Sex.MALE.ordinal()] = 1;
            map[Sex.FEMALE.ordinal()] = 2;
        }
    } 
    
    public static void foo(Sex sex) { 
        int x = $MAP.map[sex.ordinal()];
            switch (x) { 
                case 1:
                    System.out.println("男");
                    break;
                case 2:
                    System.out.println("女");
                    break;
            }
        }
    }

## 7.枚举 ##

JDK7以后Java引入了枚举类，它也是一个语法糖。

以上一个性别类型为例：

enum Sex { 
        MALE, FEMALE
    }

转换后（idea依旧不能转换）：

public final class Sex extends Enum<Sex> { 
        public static final Sex MALE;
        public static final Sex FEMALE;
        private static final Sex[] $VALUES;
        
        static { 
            MALE = new Sex("MALE", 0);
            FEMALE = new Sex("FEMALE", 1);
            $VALUES = new Sex[]{ MALE, FEMALE};
        }
        
        /** * Sole constructor. Programmers cannot invoke this constructor. * It is for use by code emitted by the compiler in response to * enum type declarations * used to declare it. * @param ordinal - The ordinal of this enumeration constant (its position * in the enum declaration, where the initial constant is assigned */
        private Sex(String name, int ordinal) { 
          super(name, ordinal);
        }
        
        public static Sex[] values() { 
          return $VALUES.clone();
        }
        
        public static Sex valueOf(String name) { 
          return Enum.valueOf(Sex.class, name);
        }
    }

## 8.try-with-resourcs ##

JDK7加入对需要关闭资源处理的特殊语法。

try(资源大小 = 创建对象资源){ 
      
    }catch(){ 
      
    }

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

public class Test6 { 
    
        public static void main(String[] args) { 
            try(InputStream stream = new FileInputStream("F://test.txt")) { 
                System.out.println(stream);
            }catch (Exception e){ 
                e.printStackTrace();
            }
        }
    }

会被转换为；

public class Test6 { 
        public Test6() { 
        }
    
        public static void main(String[] args) { 
            try { 
                InputStream stream = new FileInputStream("F://test.txt");
                Throwable var2 = null;
    
                try { 
                    System.out.println(stream);
                } catch (Throwable var12) { 
                    //var2是可能出现的异常
                    var2 = var12;
                    throw var12;
                } finally { 
                    //判断资源是否为空
                    if (stream != null) { 
                        //如果代码出现异常
                        if (var2 != null) { 
                            try { 
                                stream.close();
                            } catch (Throwable var11) { 
                                //关闭资源时出现异常，作为被压制异常添加
                                var2.addSuppressed(var11);
                            }
                        } else { 
                            //如果代码没有异常，close出现的异常就是catch中var12
                            stream.close();
                        }
                    }
    
                }
            } catch (Exception var14) { 
                var14.printStackTrace();
            }
    
        }
    }

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

public class Test6_1 { 
    
        public static void main(String[] args) { 
            try(Myresource myresource = new Myresource()) { 
                int a = 1/0;
            }catch (Exception e){ 
                e.printStackTrace();
            }
        }
    }
    
    class Myresource implements AutoCloseable{ 
    
        @Override
        public void close() throws Exception { 
            throw new IOException("close异常");
        }
    }

其输出为；

java.lang.ArithmeticException: / by zero
    	at wf.test.Test6_1.main(Test6_1.java:9)
    	Suppressed: java.io.IOException: close异常
    		at wf.test.Myresource.close(Test6_1.java:20)
    		at wf.test.Test6_1.main(Test6_1.java:10)

TWR将两个异常信息都保留了下来。

## 9.方法重写时的桥接方法 ##

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

*  父子类的返回值完全一致
 *  子类返回值可以是父类返回值的子类（比较绕口，见下面的例子）

class A{ 
        public Number m(){ 
            return 1;
        }
    }
    
    class B extends A{ 
        public Integer m(){ 
            return 2;
        }
    }

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

class B extends A { 
        public Integer m() { 
            return 2;
        } 
        // 此方法才是真正重写了父类 public Number m() 方法
        public synthetic bridge Number m() { 
        // 调用 public Integer m()
            return m();
        }
    }

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

public class Test7 { 
    
        public static void main(String[] args) { 
            for (Method m :B.class.getDeclaredMethods()) { 
                System.out.println(m);
            }
    
            A a = new B();
            System.out.println(a.m());
        }
    }

输出结果：

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

也可以验证该方法重写起作用了。

## 10.匿名内部类 ##

代码：

public class Candy11 { 
    
        public static void main(String[] args) { 
            Runnable runnable = new Runnable() { 
                @Override
                public void run() { 
                    System.out.println("hello ");
                }
            };
        }

转码后：

// 额外生成的类
    final class Candy11$1 implements Runnable { 
        Candy11$1() { 
        }
        public void run() { 
            System.out.println("ok");
        }
    }
    public class Candy11 { 
        public static void main(String[] args) { 
            Runnable runnable = new Candy11$1();
        }
    }

当匿名内部类引用外部类变量时

private static void test(final int x) { 
        Runnable runnable = new Runnable() { 
            @Override
            public void run() { 
                System.out.println("hello " + x);
            }
        };
        runnable.run();
    }

转换后：

// 额外生成的类
    final class Candy11$1 implements Runnable { 
        int val$x;
        Candy11$1(int x) { 
            this.val$x = x;
        }
        public void run() { 
            System.out.println("ok:" + this.val$x);
        }
    }
    public static void test(final int x) { 
        Runnable runnable = new Candy11$1(x);
    }

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