devbox
pnstu
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

java语法糖

作者：pnstu | 2024-02-04 17:38:01

赞

踩

java语法糖

概述

        几乎所有的语言都涉及到语法糖，语法糖时啥呢？语法糖其实就是在开发中方便程序员用的一些语法，该语法和正常语法的区别就在于：语法糖在底层其时是不能够被一次性直接实现的，它们需要依靠一些技术或普通语法实现。当我们编译.java文件为.class文件的时候，底层编译器解析到语法糖时就会进行解语法糖操作，还原为普通语法。

        这些语法虽然不会提供实质性的功能改进，但是能提高我们开发的效率，提供严谨性，但一门语言的语法糖不是越多越好，大量的添加语法糖会让开发者产生依赖，无法知道程序代码的真实行为。

      java中常见的语法糖有默认构造器、泛型、自动拆箱自动装箱、  增强for循环、可变长参数……

泛型

        在jdk5的时候java推出了泛型的功能，我们来谈谈java泛型的故事和其实现原理。

java和c#的泛型

        java和C#在同一年推出了泛型的功能，但是它们两泛型的实现并不相同，java的泛型采用了"类型擦除式泛型"，而C#采用的是"具现化式泛型"，所谓具现化就是比较具体的，泛型在C#里是真实存在的，在运行环境中泛型充当了一个占位符，其中List<String>和List<int>不是一个类型，因为泛型的存在使得虽然裸类型(泛型前面的类型)相同但是整体却不相同；而类型擦除式泛型是指泛型只在源程序中存在，不会出现在编译后的class文件中，编译时泛型全部会被擦除替换为原来的裸类型，并且在相应的地方加上了强制转换代码，所以List<String>和List<int>其实是一个类型。如下C#可以正常编译，但是java里都是不合法的，因为编译后这些泛型都被擦出了，代码逻辑就不正常了。

  1. public class GenericsType<T> {
  2.     public void doSomething(Object item){
  3.         if(item instanceof T){
  4.             ……
  5.         }
  6.         T newIntem =new T();
  7.         T[]  itemArray=new T[10];
  8.     }
  9. }

        java泛型还有一个缺点就是效率低下，因为它会给程序带来不计其数的拆箱和装箱操作。

        总结一下，因为jdk5才出的泛型，所以java开发人员为了保证jdk5之前开发的java代码也能完美兼容，所以实现泛型有很多束缚，有两种实现方式选择，分别是java和C#两条路。而C#是当时才出现2年时间，完全没有太多的顾虑，它采用了开发一套平行于需要加泛型的类型的一套新的类型，以前的老类型可以用，新的类型只不过是在老类型之上添加了一个泛型标志而已。而java不一样，它在jdk1.2就已经这样选择过了，Vector类型用ArrayList代替、HashTable用HashMap代替……，如果因为泛型而分别在这些老新类型上平行的开发一套带有泛型的类型如Vector<T>、ArrayList<T>等，这就可能导致出现一片开发人员的骂声。

类型擦除

        如ArrayList<T>的裸类型为ArrayList类型，ArrayList<Integer>和ArrayList<String>都是ArrayList的子类型(不是面向对象的那种子类型)，系统会允许子类到父类的完美转换。这些子类型在编译时直接被还原为裸类型了，只有元素访问和修改时自动插入一些强制类型转换和检查命令。

 ArrayList可以理解为就是ArrayList<Object> 

如下面一段代码，在class文件中其实是另一个模样。

  1.   ArrayList<String> list = new ArrayList<>();
  2.   list.add("123");
  3.   list.add("java");
  4.   System.out.println(list.get(0));
  5.   System.out.println(list.get(1));

反编译后产看结果：

  1. ArrayList list = new ArrayList();//转为裸类型了
  2. list.add("123");//实际调用的是list.add(Object e)
  3. list.add("java");
  4. System.out.println((String)list.get(0));//添加了强制转换
  5. System.out.println((String)list.get(1));//实际取得是Object类型强转为String类型

        类型擦除方法还有一个缺陷就是对原始类型数据的支持又成了新麻烦，如下一段代码(目前java不支持)

  1. ArrayList<int> ilist = new ArrayList<int>();
  2. ArrayList<long> llist = new ArrayList<long>();
  3. ArrayList list;
  4. list=ilist;
  5. list=llist;

如果当类型擦出了，可以想象得出当往下用到强制类型转换时，代码就往下执行不了了，因为不支持int、long类型和Object类型的转换，只有引用类型才能全是Object的子类，才能转换，所以java简单粗暴的禁止掉了原生类型的泛型，这也导致了无数的装箱拆箱。

还有如下代码，该代码是不能被编译通过的，因为类型擦除后压根就是同一个类型，达不到方法重载。

  1. //'doSomething(ArrayList<String>)' clashes with 'doSomething(ArrayList<Integer>)';both methods have same erasure
  2. public void doSomething(ArrayList<String> item){
  3. }
  4. public void doSomething(ArrayList<Integer> item){
  5. }

擦除法所谓的擦除仅仅是对方法的Code的属性中的字节码擦除，实际上元数据还是保留了泛型信息的，如Signature属性和LocalVariableType都是为泛型而生的。可以看到LocalVariableType Table仍然保留了方法参数泛型的信息。通过反射依然能获取这些信息

  1. ArrayList<String> list1 = new ArrayList<>();
  2. ArrayList<Integer> list2=new ArrayList<>();

上面代码的字节码为 

自动装箱、拆箱

        jdk5提供的新功能，因为泛型的加入，一些集合的泛型只支持包装类型，所以会发生很多的类型转换，也就出现了减少这种重复操作的自动拆箱和自动装箱语法糖。

  1. Integer x=1;
  2. int y=x;

如上一段代码，编译器会在编译阶段给我们的代码解语法糖改为如下代码：

  1. Integer x=Integer.valueOf(1);
  2. int y=x.intValue();

其中第一行为装箱操作，第二行为拆箱。

可变参数

可变参数也是JDK 5开始加入的新特性:

  1. public static void main(String[] args) {
  2.    f("hello","world");
  3. }
  4. public static void f(String... args){
  5.     String[]arrays=args;//直接赋值
  6.     System.out.println(arrays);
  7. }

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

  1. public static void main(String[] args) {
  2.    f(new String[]{"hello","world"});//其实就是一个数组
  3. }
  4. public static void f(String... args){
  5.     String[]arrays=args;//直接赋值
  6.     System.out.println(arrays);
  7. }

如果调用了f() 则等价代码为foo(new String[]{})，创建了一个空的数组，而不会传递null进去

增强for循环

  1. public static void main(String[] args) {
  2.     int[] array = {1, 2, 3, 4, 5};
  3.     for (int item : array) {
  4.         System.out.println(item);
  5.     }
  6. }

 上面的代码包含了两个语法糖，经过反编译之后，其实就是以下的代码：

  1. public static void main(String[] args) {
  2.     int[] array = new int[]{1, 2, 3, 4, 5};//第一个语法糖,数组赋初值的简化写法
  3.  
  4.     //开始第二个语法糖
  5.     int[] var2 = array;
  6.         
  7.     for(int var4 = 0; var4 < array.length; ++var4) {
  8.         int item = var2[var4];
  9.         System.out.println(item);
  10.     }
  11. }

如果我们遍历的不是数组而是list集合，如

  1. List<String> list= Arrays.asList("1","2","3");
  2. for (String s : list) {
  3.     System.out.println(s);
  4. }

其实就是如下代码，其中包含了3个语法糖

  1. List<String> list = Arrays.asList(new String[]{"1","2","3"});
  2. Iterator var2 = list.iterator();
  3.  
  4. while(var2.hasNext()) {
  5.     String s = (String)var2.next();
  6.     System.out.println(s);
  7. }

 集合是采用的迭代器实现的增强for循环，如果集合要使用增强for循环，那可想而知，肯定是要实现Iterable接口的。Iterable接口需要实现一个iterator()方法，返回一个Iterator迭代器，即接口定义了规范。

switch字符串与枚举

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

  1. String str = "hello";
  2. switch (str) {
  3.     case "hello": {
  4.         System.out.println("hello");
  5.         break;
  6.     }
  7.     case "world": {
  8.         System.out.println("world");
  9.         break;
  10.     }
  11. }

真实代码为：

  1.     String str = "hello";
  2.     byte var3 = -1;//该值作为标识符
  3.     //首先比较字符串的hash值
  4.     switch(str.hashCode()) {
  5.     case 99162322:
  6.         //里面的if和equals是为了防止hash冲突的
  7.         if (str.equals("hello")) {
  8.             var3 = 0;
  9.         }
  10.         break;
  11.     case 113318802:
  12.         if (str.equals("world")) {
  13.             var3 = 1;
  14.         }
  15.     }
  16.     //再根据获得的标识符来选择要执行的具体代码逻辑
  17.     switch(var3) {
  18.     case 0:
  19.         System.out.println("hello");
  20.         break;
  21.     case 1:
  22.         System.out.println("world");
  23.     }

比较hash值后再equals比较是很严谨的，不会因为hash冲突导致一系列问题。这样做是为了用hash值来提高效率，再让equals来防止hash冲突

用两个switch而不直接输出的原因可能是：直接输出没办法达到用不用break这个操作，有可能用户忘记写break了，但是直接输出不会一直输出下去而是像正常使用的一样，这就有问题。

  1. public enum Sex {
  2.     MALE,FEMALE
  3. }
  1. public static void main(String[] args) {
  2.     Sex sex = Sex.MALE;
  3.     switch (sex) {
  4.         case MALE:
  5.             System.out.println("MALE");
  6.             break;
  7.         case FEMALE:
  8.             System.out.println("FEMALE");
  9.             break;
  10.     }
  11. }

解语法糖后为：

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

枚举类

JDK 7新增了枚举类，以前面的性别枚举为例:

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

就是如下：

  1. public final class Sex extends Enum<Sex>{
  2.     public static final Sex MALE;
  3.     public static final Sex FEMALE;
  4.     public static Sex[] $VALUES;
  5.     static {
  6.         MALE=new Sex("MALE",0);
  7.         FEMALE=new Sex("FEMALE",1);
  8.         $VALUES =new Sex[]{MALE,FEMALE};
  9.     }
  10.     private Sex(String name,int ordinal){
  11.         super(name,ordinal);
  12.     }
  13.     public static Sex[] values(){
  14.         return $VALUES.clone();
  15.     }
  16.  
  17.     public static Sex valueOf(String name){
  18.         return Enum.valueOf(Sex.class,name);
  19.     }
  20. }

try-with-resource

jdk7新增的对关闭资源处理的特殊语法。

  1. try(FileInputStream stream = new FileInputStream(new File("1.txt"))){
  2.     System.out.println(stream);        
  3. } catch (Exception e) {
  4.     e.printStackTrace();
  5. }

try中的资源对象需要实现AutoCloseable接口，只要放在try的括号中不需要我们自己去关闭资源，简化开发。

其语法解糖后如下：

  1. try {
  2.     FileInputStream stream = new FileInputStream(new File("1.txt"));
  3.     Throwable var2 = null;//临时变量
  4.     
  5.     try {
  6.         //我们的代码逻辑
  7.         System.out.println(stream);
  8.     } catch (Throwable var12) {
  9.         var2 = var12;
  10.         throw var12;
  11.     } finally {
  12.         if (stream != null) {
  13.             //判断我们的代码中是否有异常    
  14.             if (var2 != null) {
  15.                 try {
  16.                     stream.close();//关闭流
  17.                 } catch (Throwable var11) {
  18.                     //防止异常丢失
  19.                     var2.addSuppressed(var11);
  20.                 }
  21.             } else {
  22.                 stream.close();
  23.             }
  24.         }
  25.  
  26.     }
  27. } catch (Exception var14) {
  28.     var14.printStackTrace();
  29. }

给我们生成了两个try语句块。

方法重写时的桥接方法

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

  • 父子类的返回值完全一致
  • 子类返回值可以是父类返回值的子类(见下面的例子)
  1. public class A {
  2.     public Number m(){
  3.         return 1;
  4.     }
  5. }
  6. class B extends A{
  7.     @Override//返回值类型必须是父类该方法的子类型
  8.     public Integer m() {
  9.         return 2;
  10.     }
  11. }

该重写时成立的，Override并没有报错。

解糖后类B如下：

  1. class B extends A{
  2.     public Integer m() {
  3.         return 2;
  4.     }
  5.     public synthetic bridge Number m(){
  6.         return m();
  7.     }
  8. }

它会给我们加上实际的方法重写，且间接调用我们原来的方法，这里的两个不认识的关键字我们是看不到的，只在jvm内部存在，这种方法就是桥接方法。

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

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

结果为：

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

匿名内部类

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

该代码编译为class文件时会自动生成一个类，名字中有$的一般都是jvm给我们自动生成的类

  1. class Candy$1 implements Runnable{
  2.     @Override
  3.     public void run() {
  4.         System.out.println("OK");
  5.     }
  6. }

再有，如果该匿名内部类中引用了外部的变量，该变量必须为final类型的

  1. public class Candy {
  2.     public static void main(String[] args) {
  3.         int x = 0;//该变量被匿名内部类所引用，jvm会给他自动加上final
  4.         //x=1; //不能给他赋值，如果赋值了就报错，Variable 'x' is accessed from within inner class, needs to be final or effectively final
  5.         Runnable run=new Runnable() {
  6.             @Override
  7.             public void run() {
  8.                 System.out.println(x);
  9.             }
  10.         };
  11.     }
  12. }

生成的类为：

  1. class Candy$1 implements Runnable{
  2.     int val$x;//新增的变量
  3.     public Candy$1(int val$x) {//构造方法里赋值
  4.         this.val$x = val$x;
  5.     }
  6.  
  7.     @Override
  8.     public void run() {
  9.         System.out.println(this.val$x);
  10.     }
  11. }

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

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/article/detail/59490
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号