@ghimi 2018-10-06T13:09:08.000000Z 字数 5892 阅读 1181

Java 语法糖详解

Java

语法糖

语法糖(Syntactic Sugar),也称糖衣语法,是由英国计算机学家 Peter.J.Landin 发明的一个术语,指在计算机语言中添加的某种语法.

这种语法对语言的功能并没有影响,但是更方便程序员使用.简而言之,语法糖让程序更加简洁,有更高的可读性.

有意思的是,在编程领域,除了语法糖,还有语法盐和语法糖精的说法,篇幅有限这里不做拓展了.

我们所熟知的编程语言中几乎都有语法糖.作者认为,语法糖的多少是评判一个语言够不够牛逼的标准之一.

很多人说 Java 是一个"低糖语言",其实从Java 7 开始 Java 语言层面上一直在添加各种糖,主要是在"Poject Coin"项目下开发.尽管现在Java有人还是认为现在的Java是低糖,未来还会持续向着"高糖"的方向发展.

解语法糖

前面提到过,语法糖的存在主要是方便开发人员使用.但其实,Java虚拟机并不支持这些语法糖,这些语法糖在编译阶段就会被还原成简单的基础语法结构,这个过程就是解语法糖.

说到编译,大家肯定都知道,Java语言中,javac命令可以将后缀名为.java的源文件编译为后缀名为.class的可以运行于Java虚拟机的字节码.
如果你去看com.sun.tools.javac.main.JavaComiler的源码,你会发现在compile()中有一个步骤就是调用desugar(),这个方法就是负责解语法糖的实现的.

Java中最常用的语法糖主要有泛型,变长参数,条件编译,自动拆装箱,内部类等.本文主要来分析下这些语法糖背后的原理,一步一步剥去糖衣,看看其本质.

糖块一,switch 支持 String 与枚举

前面提到过,从Java 7 开始,Java语言中的语法糖在逐渐丰富,其中一个比较重要的就是Java 7 中switch开始支持String

在开始 coding 之前先科普下,Java中的switch自身原本就支持基本类型.比如int,char等.对于int类型,直接进行处置的比较.
对于char类型则是比较其 ascii 码.所以,对于编译器来说,switch中气质只能使用整形,任何类型的比较都要转换成整形.比如 byte,short,char(ascii码是整形)以及int.
那么接下来看下switch对String的支持,有以下代码:

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

反编译后内容如下:

public class switchDemoString{
    public switchDemoString(){
    }
    public static void main(String args[]){
        String str = "world";
        String s;
        switch((s = str).hashCode()){
            default:break;
            case 99162322:{
                if(s.equals("hello")){
                    System.out.println("hello");
                }
            }break;
            case 113318802:{
                if(s.equals("world")){
                    System.out.println("world");
                }break;
            }
        }
    }
}

看到这个代码,你知道远在字符串的switch是通过equals()和hashCode()方法来实现的.还好hashCode()方法返回的是int,而不是long.

仔细看下可以发现,进行switch的实际是哈希值,然后通过使用equals方法比较进行安全检查,这个检查是必要的,因为哈希可能会发生碰撞.因此它的性能是不如使用枚举进行switch或者使用纯整数常量,但这也不是很差.

糖块二,泛型

我们都知道,很多语言都是支持泛型的,但是很多人不知道的是,不同的编译器对于泛型的处理方式是不同的.
通常情况下,一个编译器处理泛型有两种方式:Code specialization和Code sharing.C++和C#是使用Code specialization的处理机制,而Java使用的是Code sharing 的机制.

Code sharing 方式为每个泛型类型创建唯一的字节码表示,并且将该泛型类型的实例都映射到这个唯一的字节码表示上.将多种泛型类型实例映射到唯一的字节码表示是通过类型擦除(type erasue)实现的.

也就是说,对于Java 虚拟机来说,他根本不认识Map<String,String> map这样的语法.需要在编译阶段通过类型擦除的方式进行解语法糖.
类型擦除的主要过程如下:
1. 将所有的泛型参数用其最左边界(最顶级的父类型)类型替换.
2. 移除所有的类型参数
以下代码:

Map<String,String> map = new HashMap<String,String>();
map.put("name","hollis");
map.put("wechat","Hollis");
map.put("blog","www.baidu.com");

解语法糖之后就会变成:

Map map = new HashMap();
map.put("name","hollis");
map.put("wechat","Hollis");
map.put("blog","www.baidu.com");

以下代码:

public static <A extends Coomparable<A>> A max(Collection<A> xs){
    Iterator<A> xi = sx.iterator();
    A w = xi.next();
    while(xi.hasNext()){
        A x = xi.next();
        if(w.compareTo(x) < 0 )w = x;
    }
    return w;
}

类型擦除后会变成:

public static Comparable max(Collection xs){
    Iterator xi = xs.iterator();
    Comparable w = (Comparable)xi.next();
    while(xi.hasNext()){
        Comparable x = (Comparable) xi.next();
        if(w.compareTo(x) < 0) w = x;
    }
    return w;
}

虚拟机中没有泛型,只有普通类和普通方法,所有泛型类的类型参数在编译时都会被擦除,泛型类并没有自己独有的Class类对象.
比如不存在List<String>.class或是List<Integer>.class,而只有List.class

糖块三,自动装箱与拆箱

自动装箱就是Java自动将原始类型值转换成对应的对象,比如讲int 的变量转换成Integer对象,这个过程叫做装箱.
反之将Integer对象转换成int类型值,这个过程叫做拆箱.因为这里的装箱和拆箱是自动进行的非人为转换,所以就称作为自动装箱和拆箱.
原始类型byte,short,char,int,long,float,double和boolean对应的封装类为Byte,Short,Character,Integer,Long,Float,Double,Boolean.
先来看个自动装箱的代码:

public static void main(String[] args){
    int i = 10;
    Integer n = i;
}

反编译后代码如下:

public static void main(String args[]){
    int i = 10;
    Integer n = Integer.valueOf(i);
}

再来看个自动拆箱的代码:

public static void main(String[] args){
    Integer i = 10;
    int n = i;
}

反编译后代码如下:

public static void main(String[] args){
    Integer i = Integer.valueOf(10);
    int n = i.intValue();
}

从反编译得到的内容可以看出,在装箱的时候自动调用的是Integer的valueOf(int)方法.而在拆箱的时候自动调用的是Integer的intValue方法.
所以,装箱过程是通过调用包装器的valueOf方法实现的,而拆箱过程是通过调用包装器的xxxValue方法实现的.

糖块四,方法变长参数

可变参数(variable arguments)是在Java 1.5中引入的一个特性,它允许一个方法吧任意数量的值作为参数.
看以下可变参数代码,其中 print 方法接受可变长参数:

public static void main(String[] args){
    print("Holis","1","4323");
}
public static void print(String... strs){
    for(int i = 0;i < strs.length ; i++){
        System.out.println(strs[i])
    }
}

反编译后代码:

public static void main(Strig[] args){
    print(new String[]{"Holis","1","4323"});
}
public static transient void print(String[] strs){
    for(int i = 0 ; i < strs.length ; i++){
        System.out.println(strs[i])
    }
}

从反编译后代码可以看出,可变参数在被使用的时候,它首先会创建一个数组,数组的长度就是调用该方法时传递的实参的个数.
然后再把参数值全部方法全放到这个数组当中,然后再把这个数组作为参数传递到被调用的方法中.

反编译后的print方法声明中有一个transient标示,是不是很奇怪?transient不是不可以修饰方法吗?transient不是和序列化有关吗?transient在这里的作用是什么?因为这个与本文关系不打,这里不做深入分析了.

糖块五,枚举

Java SE5提供了一种新的类型-Java的枚举类型,关键字enum可以将一组具名的值的有限集合创建为一个新的类型,而这些具名的值可以作为常规的程序组件使用,这是一种非常有用的功能.
要想看源码,首先得有一个类吧,那么枚举类型到底是什么类呢?是enum吗?答案很明显不是,enum就和class一样,只是一个关键字,他并不是一个类那么枚举类型是由什么类维护的呢?我们简单写一个枚举:

public enum t {
    SPRING,SUMMER;
}

然后我们使用反编译,看看这段代码到底是怎么实现的,反编译后内容如下:

public final class T extends java.lang.Enum<T> {
  public static final T SPRING;
  public static final T SUMMER;
  private static final T[] $VALUES;
  public static T[] values();
  public static T valueOf(java.lang.String);
  private T();
  static {};
}

通过反编译后代码我们可以看到,public final class T extends Enum,说明,该类是继承了Enum类的,同时final关键字告诉我们,这个类也是不能被继承的.
当我们使用enum来定义一个枚举类型的时候,编译器会自动帮我们创建一个final类型的类继承Enum类,所以枚举类型不能被继承.

糖块六,内部类

内部类又成为嵌套类,可以把内部类理解为外部类的一个普通成员.内部类之所以也是语法糖,是因为它仅仅是一个编译时的概念.
OutterClass.java里面定义了一个内部类inner,一旦编译成功,就会生成两个完全不同的.class文件了,分别是out.class和outer$inner.class.所以内部类的名字完全可以和它的外部类名字相同.

public class OutterClass{
    private String userName;
    public String getUserName(){
        return userName;
    }
    public String setUserName(userName){
        this.userName = userName;
    }
    public static void main(String[] args){
        classs InnerClasss{
            private String name;
            public String getName(){
                return name;
            }
            public void setName(String name){
                this.name = name;
            }
        }
    }
}

以上代码编译后会生成两个class文件:OutterClass$InnerClass.class,OUterClass.class.
当我们尝试对OuterClass.class文件进行反编译的时候,命令行会打印以下内容:Parsing OutterClasss.class...Parsing inner classs OutterClasss$InnerClasss.class... GeneratingOutterClass.jad
它会把两个文件全部进行反编译,然后一起生成一个OutterClass.jad文件.文件内容如下:

public class OutterClasss{
    class InnerClasss{
        public String getName(){
            return name;
        }
        public void setName(String name){
            this.name = name;
        }
        private String name;
        final OutterClass this$0;
        InnerClass(){
            this.this$0 = OutterClass.this;
            super();
        }
    }
    public OutterClass(){
    }
    public String getUserName(){
        return userName;
    }
    public void setUserName(String userName){
        this.userNaem = userName;
    }
    public static void main(String[] args1){
    }
    private String userName;
}