JVM 基础篇15 —— 编译期(二)

Java语法糖

几乎各种语言或多或少都提供过一些语法糖来方便程序员的代码开发,这些语法糖虽然不会提供实质性的功能改进,但是它们或能提高效率,或能提升语法的严谨性,或能减少编码出错的机会。不过也有一种观点认为语法糖并不一定都是有益的,大量添加和使用含糖的语法容易让程序员产生依赖,无法看清语法糖的糖衣背后程序代码的真实面目。

泛型与类型擦除

泛型是JDK 1.5的一项特性,它的本质是参数化类型(Parameterized Type)的应用,也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口和泛型方法。

泛型思想早在C++语言的模板(Templates)中就开始生根发芽,在Java语言还没有出现泛型时,只能通过Object是所有类型的父类和类型强制转换两个特点的配合来实现类型泛化。由于Java语言里面所有的类型都继承于java.lang.Object,那Object转型成任何对象都是有可能的。但是也因为有无限的可能性,就只有程序员和运行期的虚拟机才知道这个Object到底是个什么类型的对象。在编译期间,编译器无法检查这个Object的强制转型是否成功,如果仅仅依赖程序员去保障这项操作的正确性,许多ClassCastException的风险就会被转嫁到程序运行期中。

泛型技术在C#和Java之中的使用方式看似相同,但实现上却有着根本性的分歧,C#里面泛型无论在程序源码中、编译后的IL中(Intermediate Language,中间语言,这时候泛型是一个占位符)还是运行期的CLR中都是切实存在的,List<int>与List<String>就是两个不同的类型,它们在系统运行期生成,有自己的虚方法表和类型数据,这种实现称为类型膨胀,基于这种方法实现的泛型被称为真实泛型。

Java语言中的泛型则不一样,它只在程序源码中存在,在编译后的字节码文件中,就已经被替换为原来的原生类型(Raw Type,也称为裸类型)了,并且在相应的地方插入了强制转型代码,因此对于运行期的Java语言来说,ArrayList<int>与ArrayList<String>就是同一个类。所以说泛型技术实际上是Java语言的一颗语法糖,Java语言中的泛型实现方法称为类型擦除,基于这种方法实现的泛型被称为伪泛型。

public static void main(String[]args){
	Map<String, String> map = new HashMap<>();
	map.put("hello","world");
	map.put("Java","伪泛型");
	System.out.println(map.get("hello"));
	System.out.println(map.get("Java"));
}

泛型擦除后

public static void main(String[]args){
	Map map = new HashMap();
	map.put("hello","world");
	map.put("Java","伪泛型");
	System.out.println((String)map.get("hello"));
	System.out.println((String)map.get("Java"));
}

关于Java伪泛型的批判声此起彼伏,如强制转型操作和运行期缺少针对类型的优化,无法重载等。

泛型与重载

见下面的代码:


	public static void method(List<String> list){
		System.out.println("invoke method(List<String>list)");
	}

	public static void method(List<Integer> list){
		System.out.println("invoke method(List<Integer> list)");
	}

毫无疑问,这段代码是无法编译通过的。因为参数List<Integer>和List<String>编译之后都被擦除了,变成了一样的原生类型List<E>,擦除动作导致这两个方法的特征签名变得一模一样。但是需要注意的是泛型擦除成相同的原生类型只是无法重载的一部分原因。

如:

    public class GenericTypes{

        public static String method(List<String> list){
            System.out.println("invoke method(List<String>list)");
            return"";
        }

        public static int method(List<Integer>list){
            System.out.println("invoke method(List<Integer>list)");
            return 1;
        }

        public static void main(String[]args){
            method(new ArrayList<String>()));
            method(new ArrayList<Integer>());
        }
    }

执行结果:

invoke method(List<String>list)
invoke method(List<Integer>list)

出乎意料这次居然编译和执行成功,这是因为两个mehtod()方法加入了不同的返回值后才能共存在一个Class文件之中。

方法重载要求方法具备不同的特征签名,返回值并不包含在方法的特征签名之中,所以返回值不参与重载选择但在Class文件格式之中,只要描述符不是完全一致的两个方法就可以共存。也就是说两个方法如果有相同的名称和特征签名,但返回值不同,那它们也是可以合法地共存于一个Class文件中的。

由于Java泛型的引入,各种场景(虚拟机解析、反射等)下的方法调用都可能对原有的基础产生影响和新的需求,如在泛型类中如何获取传入的参数化类型等。所以JCP组织对虚拟机规范做出了相应的修改,引入了诸如SignatureLocalVariableTypeTable等新的属性用于解决伴随泛型而来的参数类型的识别问题,Signature是其中最重要的一项属性,它的作用就是存储一个方法在字节码层面的特征签名,这个属性中保存的参数类型并不是原生类型,而是包括了参数化类型的信息。修改后的虚拟机规范要求所有能识别49.0以上版本的Class文件的虚拟机都要能正确地识别Signature参数。

从上面的例子可以看到擦除法对实际编码带来的影响,由于List<String>和List<Integer>擦除后是同一个类型,我们只能添加两个并不需要实际使用到的返回值才能完成重载,这是一种毫无优雅和美感可言的解决方案。同时,从Signature属性的出现我们还可以得出结论,擦除法所谓的擦除,仅仅是对方法的Code属性中的字节码进行擦除,实际上元数据中还是保留了泛型信息,这也是我们能通过反射手段取得参数化类型的根本依据。

自动装箱、拆箱与遍历循环

如下面代码:

public static void main(String[]args){

	List<Integer> list = Arrays.asList(1,2,3,4);
	/*
	如果在JDK 1.7中,还有另外一颗语法糖,
	能让上面这句代码进一步简写成List<Integer> list = [1,2,3,4];
	*/
	int sum = 0;
	for(int i : list){
		sum += i;
	}
	System.out.println(sum);
}

编译后:

public static void main(String[]args){
	List list = Arrays.asList(new Integer[]{
	Integer.valueOf(1);
	Integer.valueOf(2);
	Integer.valueOf(3);
	Integer.valueOf(4);
	int sum = 0;
	
	for(Iterator localIterator=list.iterator();localIterator.hasNext();){
		int i=((Integer)localIterator.next()).intValue();
		sum+=i;
	}
	System.out.println(sum);
}

上面代码中一共包含了泛型、自动装箱、自动拆箱、遍历循环与变长参数五种语法糖.

自动装箱、拆箱在编译之后被转化成了对应的包装和还原方法,如本例子中的Integer.valueOf()Integer.intValue()方法.

遍历循环则是把代码还原成了迭代器的实现,这也是为何遍历循环需要被遍历的类实现Iterable接口的原因

最后变长参数,在调用的时候变成了一个数组类型的参数,在变长参数出现之前,程序员就是使用数组来完成类似功能的。

在使用语法糖时往往需要小心,如:

    public static void main(String[]args){
        Integer a = 1;
        Integer b = 2;
        Integer c = 3;
        Integer d = 3;
        Integer e = 321;
        Integer f = 321;
        Long g = 3L;

        System.out.println(c == d);
        System.out.println(e == f);
        System.out.println(c == (a + b));
        System.out.println(c.equals(a + b));
        System.out.println(g == (a + b));
        System.out.println(g.equals(a + b));
    }

因为语法糖在编译后和数值缓存的原因,将输出:

true
false
true
true
true
false

条件编译

许多程序设计语言都提供了条件编译的途径,如C、C++ 中使用预处理器指示符(#ifdef)来完成条件编译。C、C++的预处理器最初的任务是解决编译时的代码依赖关系(众所周知的#include预处理命令),而在Java语言之中并没有使用预处理器,因为Java语言天然的编译方式(编译器并非一个一个地编译Java文件,而是将所有的编译单元的语法树顶级节点输入到待处理列表后再进行编译,因此各个文件之间能够互相提供符号信息)无须使用预处理器。所以Java使用条件为常量的if语句。

    public static void main(String[]args){
        if(true){
            System.out.println("block 1");
        }else{
            System.out.println("block 2");
        }
    }

此代码中的if语句不同于其他Java代码,它在编译阶段就会被“运行”,生成的字节码之中只包括“System.out.println("block 1");”一条语句,并不会包含if语句及另外一个分子中的“System.out.println("block 2");”

此代码编译后Class文件的反编译结果:

public static void main(String[]args){
	System.out.println("block 1");
}

但是只能使用条件为常量的if语句才能达到上述效果,如果使用常量与其他带有条件判断能力的语句搭配,则可能在控制流分析中提示错误,被拒绝编译。

Java语言中条件编译的实现,也是Java语言的一颗语法糖,根据布尔常量值的真假,编译器将会把分支中不成立的代码块消除掉,这一工作将在编译器解除语法糖的阶段(com.sun.tools.javac.comp.Lower类中)完成。由于这种条件编译的实现方式使用了if语句,所以它必须遵循最基本的Java语法,只能写在方法体内部,因此它只能实现语句基本块(Block)级别的条件编译,而没有办法实现根据条件调整整个Java类的结构。

更新时间:2020-09-01 21:54:11

本文由 寻非 创作,如果您觉得本文不错,请随意赞赏
采用 知识共享署名4.0 国际许可协议进行许可
本站文章除注明转载/出处外,均为本站原创或翻译,转载前请务必署名
原文链接:https://www.zhouning.group/archives/jvm基础篇15编译期二
最后更新:2020-09-01 21:54:11

评论

Your browser is out of date!

Update your browser to view this website correctly. Update my browser now

×