文章目录⭐️写在前面
这里是温文艾尔の学习之路如果对你有帮助，给博主一个免费的点赞以示鼓励把QAQ博客主页 温文艾尔の学习小屋⭐️更多文章请关注温文艾尔主页文章发布日期：2022.02.08java学习之路！欢迎各位点赞评论收藏⭐️新年快乐朋友们jvm学习之路！⭐️上一篇内容：【JVM】JVM05(从字节码角度分析i++和++i的执行流程))
⭐️1编译期处理（语法糖）⭐️1.1默认构造器⭐️1.2自动拆装箱⭐️1.3泛型集合取值⭐️1.4可变参数⭐️1.5 foreach循环⭐️1.6switch字符串⭐️1.7switch枚举⭐️1.8枚举类⭐️1.9 try-with-resources⭐️1.10方法重写时的桥接方法⭐️1.11匿名内部类
⭐️1编译期处理（语法糖）
所谓语法糖，其实就是指java编译器把*.java源码编译为*.class字节码的过程中，自动生成和转换的一些代码，主要是为了减轻程序员的负担，算是java编译器给我们的一个额外福利（给糖吃）
⭐️1.1默认构造器注意以下代码的分析，借助javap工具，idea的反编译功能，idea插件jclasslib等工具。另外，编译器转换的结果直接就是class字节码，只是为了便于阅读，给出了几乎等价的java源码方式，并不是编译器还会转换出中间的java源码，切记。
public class Candy1{}
编译成class后的代码：
public class Candy1{ //这个无参构造器是编译器帮助我们加上的 public Candy1(){ super();//即调用父类Object的无参构造方法 }}
⭐️1.2自动拆装箱这个特性是JDK5开始加入的，代码片段1：
public class Demo01 { public static void main(String[] args) { Integer x = 1; int y = x; }}
上面代码在JDK5之前是无法编译通过的，必须改写为代码片段2：
public class Demo01 { public static void main(String[] args) { Integer x = Integer.valueOf(1); int y = x.intValue(); }}
⭐️1.3泛型集合取值显然之前版本的代码太麻烦了，需要在基本类型和包装类型之间来回转换（尤其是集合类中操作的都是包装类型），因此这些转化的事情在JDK5以后都由编译器在编译阶段完成。即代码片段1都会在编译阶段被转换为代码片段2
泛型也是在JDK5开始加入的特性，但java在编译泛型代码后会执行泛型擦除的动作，即泛型信息在编译为字节码之后就丢失了，实际的类型都当做了Object类型来处理
public class Demo02 { public static void main(String[] args) { List
所以在取值时，编译器真正生成的字节码中，还要额外做一个类型转换的操作：
//需要将Object转为Integer Integer x = ( Integer)list.get(0);
如果前面的x变量类型修改为int基本类型那么最终生成的字节码是：
//需要将Object转为Integerint x = ((Integer)list.get(0)).intValue();
这些事情现在都不用我们自己做
擦除的是字节码上的泛型信息，可以看到LocalVariableTypeTable仍然保留了方法参数泛型的信息
Compiled from "Demo02.java"public class com.wql.jvm.Candy.Demo02 minor version: 0 major version: 52 flags: (0x0021) ACC_PUBLIC, ACC_SUPER this_class: #8 // com/wql/jvm/Candy/Demo02 super_class: #9 // java/lang/Object interfaces: 0, fields: 0, methods: 2, attributes: 1Constant pool: #1 = Methodref #9.#29 // java/lang/Object."
使用反射，仍然能够获得这些信息
public Set
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] - %sn", i, arguments[i]); } }}
输出
可变参数也是JDK5开始加入的新特性：
例如:
public class Demo03 { public static void foo(String..、args){ String[] array = args; System.out.println(array); } public static void main(String[] args) { foo("hello","java"); }}
可变参数String… args 实是-个string[] args, 从代码中的赋值语句中就可以看出来。同样java编译器会在编译期间将上述代码变换为:
public class Demo03 { public static void foo(String[] args){ String[] array = args; System.out.println(array); } public static void main(String[] args) { foo(new String[]{"hello","java"}); }}
注意：
如果调用了foo()，则等价代码为foo(new String[]{}),创建了一个空的数组，而不会传递null进去
JDK5开始引入的语法糖，数组的循环：
public class Demo04 { public static void main(String[] args) { int[] array = {1,2,3,4,5};//数组赋初值的简化写法也是语法糖 for (int e:array){ System.out.println(e); } }}
会被编译器转换为：
public class Demo04 { public static void main(String[] args) { int[] array = new int[]{1,2,3,4,5};//数组赋初值的简化写法也是语法糖 for (int i = 0; i < array.length; ++i) { int e =array[i]; System.out.println(e); } }}
而集合的循环：
public class Demo05 { public static void main(String[] args) { List
实际被编译器转换为对迭代器的调用：
public class Demo05 { public static void main(String[] args) { List
注意：
foreach循环写法，能够配合数组，以及所有实现了Iterable接口的集合类一起使用，其中Iterable用来获取集合的迭代器（Iterator）
从JDK7开始，switch可以作用于字符串和枚举类，这个功能其实也是语法糖，例如：
public class Demo06 { public static void choose(String str){ switch (str){ case "hello":{ System.out.println("h"); break; } case "world":{ System.out.println("w"); break; } } }}
注意：
switch配合String和枚举使用时，变量不能为null，原因分析完语法糖转换后的代码应当自然清楚会被编译器转换为：
public class Demo06 { public static void choose(String str){ byte x = -1; switch (str.hashCode()){ case 99162322://hello的hashCode if (str.equals("hello")){ x=0; } break; case 113318802://world的hashCode if (str.equals("world")){ x=1; } } switch (x){ case 0: System.out.println("h"); break; case 1: System.out.println("w"); } }}
可以看到，执行了两边switch，第一遍是根据字符串的hashCode和equals将字符串的转换为相应byte类型，第二遍才是利用byte执行进行比较
为什么第一遍时必须比较hashCode，有利用equals作比较呢？hashCode是为了提高效率，减少可能的比较；而equals是为了防止hashCode冲突，例如BM和C，这两个字符串的hashCode值都是2123，如果有如下代码：会被编译器转换为：
public class Demo07 { public static void choose(String str) { byte x = -1; switch (str.hashCode()){ case 2123: //hashCode值相等，需要进一步用equals比较 if (str.equals("C")){ x=0; }else if (str.equals("BM")){ x=0; } default: switch (x){ case 0: System.out.println("h"); break; case 1: System.out.println("w"); } } }}
⭐️1.7switch枚举switch枚举的例子，原始代码：
enum Sex { MALE,FEMALE}public class Demo08 { public static void foo(Sex sex){ switch (sex){ case MALE: System.out.println("男");break; case FEMALE: System.out.println("女");break; } }}
转换后代码：
public class Demo09 { static class $MAP{ 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; } }}
⭐️1.8枚举类JDK7新增了枚举类，以前面的性别枚举为例：
enum Sex { MALE,FEMALE}
转换后代码：
public final class Sex extends Enum
JDK7开始新增了对需要关闭的资源处理的特殊语法try-with-resources:
try(资源变量 = 创建资源对象){ }catch(){ }
其中资源对象需要实现AutoCloseable接口，例如InputStream、OutputStream、Connection、Statement、ResultSet等接口都实现了AutoCloseable，使用try-with-resources可以不用写finally语句块，编译器会帮助生成关闭资源代码，例如：
public class Demo11 { public static void main(String[] args) { try(InputStream is = new FileInputStream("d:\1.txt")) { System.out.println(is); }catch (IOException e){ e.printStackTrace(); } }}
会被转换为：
public static void main(String[] args) { try { InputStream is = new FileInputStream("d:\1.txt"); Throwable t = null; try { System.out.println(is); } catch (Throwable e1) { // t 是我们代码出现的异常 t = e1; throw e1; } finally { // 判断了资源不为空 if (is != null) { // 如果我们代码有异常 if (t != null) { try { is.close(); } catch (Throwable e2) { // 如果 close 出现异常，作为被压制异常添加 t.addSuppressed(e2); } } else { // 如果我们代码没有异常，close 出现的异常就是最后 catch 块中的 e is.close(); } } } } catch (IOException e) { e.printStackTrace(); } }}
希望在关闭异常时也有可能发生异常,try中的异常和资源关闭中的异常都想保留就需要t.addSuppressed(e2);
为什么要设计一个t.addSuppressed(e2);(添加被压制异常)的方法呢？是为了防止异常信息的丢失（想想try-with-resources生成的finally中如果抛出了异常）：
例如
public class Demo12 { public static void main(String[] args) { try(MyResource resource = new MyResource()) { int i = 1/0; }catch (Exception e){ e.printStackTrace(); } }}class MyResource implements AutoCloseable{ public void close() throws Exception{ throw new Exception("close 异常"); }}
外层异常为int i = 1/0;，内层异常为资源关闭时的异常
可以看到两个异常都没有丢
我们都知道，方法重写时对返回值分两种情况：
父子类的返回值完全一致子类返回值可以是父类返回值的子类（比较绕口，见下面的例子）
class A{ public Number m(){ return 1; }}class B extends A { @Override //子类m方法的返回值是Integer是父类m方法返回值Number的子类 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(); }}
synthetic bridge的含义是合成方法，对程序员是不可见的
桥接方法比较特殊，仅对java虚拟机可见，并且与原来的public Integer m()没有命名冲突，可以用下面反射代码来验证：
for (Method m : B.class.getDeclaredMethods()) { System.out.println(m);}
会输出
public java.lang.Integer test.candy.B.m()public java.lang.Number test.candy.B.m()
⭐️1.11匿名内部类源代码：
public class Demo14 { public static void main(String[] args) { Runnable runnable = new Runnable(){ @Override public void run() { System.out.println("ok"); } }; }}
转换后代码：
// 额外生成的类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(); }}
引用局部变量的匿名内部类，源代码：
public static void test(final int x){ Runnable runnable = new Runnable(){ @Override public void run() { System.out.println("ok"+x); } }; }
转换后代码
// 额外生成的类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 class Candy11 { public static void test(final int x) { Runnable runnable = new Candy11$1(x); }}
这也同时解释了为什么匿名内部类引用局部变量时，局部变量必须是final的：因为在创建Candy11$1对象时，将x的值赋给了Candy 11 1对象的valx属性，所以x不应该再发生变化了，如果变化，那么valx属性没有机会再跟着一起变化