阅读 2176

Java | 关于泛型能问的都在这里了(含Kotlin)

前言

  • 泛型(Generic Type) 无论在哪一门语言里,都是最难语法的存在,细节之繁杂、理解之困难,令人切齿;
  • 在这个系列里,我将总结Java & Kotlin中泛型的知识点,带你从 语法 & 原理 全面理解泛型。追求简单易懂又不失深度,如果能帮上忙,请务必点赞加关注!
  • 首先,尝试回答这些面试中容易出现的问题,相信看完这篇文章,这些题目都难不倒你:
1、下列代码中,编译出错的是:
public class MyClass<T> {
    private T t0; // 0
    private static T t1; // 1 
    private T func0(T t) { return t; } // 2
    private static T func1(T t) { return t; } // 3
    private static <T> T func2(T t) { return t; } // 4
}
2、泛型的存在是用来解决什么问题?
3、请说明泛型的原理,什么是泛型擦除机制,具体是怎样实现的?
复制代码

相关文章


目录


1. 泛型基础

  • 问:什么是泛型,有什么作用?

答:在定义类、接口和方法时,可以附带类型参数,使其变成泛型类、泛型接口和泛型方法。与非泛型代码相比,使用泛型有三大优点:更健壮(在编译时进行更强的类型检查)、更简洁(消除强转,编译后自动会增加强转)、更通用(代码可适用于多种类型)

  • 问:什么是类型擦除机制?

答:泛型本质上是 Javac 编译器的一颗 语法糖,这是因为:泛型是 JDK1.5 中引进的新特性,为了 向下兼容,Java 虚拟机和 Class 文件并没有提供泛型的支持,而是让编译器擦除 Code 属性中所有的泛型信息,需要注意的是,泛型信息会保留在类常量池的属性中。

  • 问:类型擦除的具体步骤?

答:类型擦除发生在编译时,具体分为以下 3 个步骤:

  • 1:擦除所有类型参数信息,如果类型参数是有界的,则将每个参数替换为其第一个边界;如果类型参数是无界的,则将其替换为 Object
  • 2:(必要时)插入类型转换,以保持类型安全
  • 3:(必要时)生成桥接方法以在子类中保留多态性

举个例子:

源码:
public class Parent<T> {
    public void func(T t){
    }
}

public class Child<T extends Number> extends Parent<T> {
    public T get() {
        return null;
    }
    public void func(T t){
    }
}

void test(){
    Child<Integer> child = new Child<>();
    Integer i = child.get();
}
---------------------------------------------------------
字节码:
public class Parent {
    public void func(Object t){
    }
}

public class Child extends Parent {
    public Number get() {
        return null;
    }
    public void func(Number t) {
    }
    
    桥方法 - synthetic
    public void func(Object t){
        func((Number)t);
    }
}

void test() {
    Child<Integer> child = new Child();
    // 插入强制类型转换
    Integer i = (Integer) child.get();
}
复制代码

步骤1:Parent 中的类型参数 T 被擦除为 Object,而 Child 中的类型参数 T 被擦除为 Number;

步骤2:child.get(); 插入了强制类型转换

步骤3:在 Child 中生成桥方法,桥方法是编译器生成的,所以会带有 synthetic 标志位。为什么子类中需要增加桥方法呢,可以先思考这个问题:假如没有桥方法,会怎么样?你可以看看下列代码调用的是子类还是父类方法:

Parent<Integer> child = new Child<>();
Parent<Integer> parent = new Parent<>();
        
child.func(1); // Parent#func(Object); 
parent.func(1); // Parent#func(Object); 
复制代码

这两句代码都会调用到 Parent#func(),如果你看过之前我写过的一篇文章,相信难不到你:《Java | 深入理解方法调用的本质(含重载与重写区别)》。在这里我简单分析下:

1、方法调用的本质是根据方法的符号引用确定方法的直接引用(入口地址)

2、这两句代码调用的方法符号引用为:

child.func(new Object()) => com/xurui/Child.func(Object)

parent.func(new Object()) => com/xurui/Parent.func(Object)

3、这两句方法调用的字节码指令为 invokevirtual

4、类加载解析阶段解析类的继承关系,生成类的虚方法表

5、调用阶段(动态分派):Child 没有重写 func(Object),所以 Child 的虚方法表中存储的是Parent#func(Object);Parent 的虚方法表中存储的是Parent#func(Object);

可以看到,即使使用对象的实际类型为 Child ,这里调用的依旧是父类的方法。这样就 失去了多态性。 因此,才需要在泛型子类中添加桥方法。

  • 问:为什么擦除后,反编译还是看到类型参数 T ?
反编译Parent.class,可以看到 T ,不是已经擦除了吗?

public class Parent<T> {
    public Parent() {
    }

    public void func(T t) {
    }
}
复制代码

答:泛型中所谓的类型擦除,其实只是擦除Code 属性中的泛型信息,在类常量池属性(Signature 属性、LocalVariableTypeTable 属性)中其实还保留着泛型信息,这也是在运行时可以反射获取泛型信息的根本依据,我在第 4 节说。

  • 问:泛型的限制 & 类型擦除会带来什么影响?

由于类型擦除的影响,在运行期是不清楚类型实参的实际类型的。为了避免程序的运行结果与程序员语义不一致的情况,泛型在使用上存在一些限制。好处是类型擦除不会为每种参数化类型创建新的类,因此泛型不会增大内存消耗。

泛型的限制


2. Kotlin的实化类型参数

前面我们提到,由于类型擦除的影响,在运行期是不清楚类型实参的实际类型的。例如下面的代码是不合法的,因为T并不是一个真正的类型,而仅仅是一个符号:

在这个函数里,我们传入一个List,企图从中过滤出 T 类型的元素:

Java:
<T> List<T> filter(List list) {
    List<T> result = new ArrayList<>();
    for (Object e : list) {
        if (e instanceof T) { // compiler error
            result.add(e);
        }
    }
    return result;
}
---------------------------------------------------
Kotlin:
fun <T> filter(list: List<*>): List<T> {
    val result = ArrayList<T>()
    for (e in list) {
        if (e is T) { // cannot check for instance of erased type: T
            result.add(e)
        }
    }
    return result
}
复制代码

Kotlin中,有一种方法可以突破这种限制,即:带实化类型参数的内联函数

Kotlin:
inline fun <reified T> filter(list: List<*>): List<T> {
    val result = ArrayList<T>()
    for (e in list) {
        if (e is T) {
            result.add(e)
        }
    }
    return result
}
复制代码

关键在于inlinereified,这两者的语义是:

  • inline(内联函数): Kotlin编译器将内联函数的字节码插入到每一次调用方法的地方
  • reified(实化类型参数): 在插入的字节码中,使用类型实参的确切类型代替类型实参

规则很好理解,对吧。很明显,当发生方法内联时,方法体字节码就变成了:

调用:
val list = listOf("", 1, false)
val strList = filter<String>(list)
---------------------------------------------------
内联后:
val result = ArrayList<String>()
for (e in list) {
    if (e is String) {
        result.add(e)
    }
}
复制代码

需要注意的是,内联函数整个方法体字节码会被插入到调用位置,因此控制内联函数体的大小。如果函数体过大,应该将不依赖于T的代码抽取到单独的非内联函数中。

注意,无法从 Java 代码里调用带实化类型参数的内联函数

实化类型参数的另一个妙用是代替 Class 对象引用,例如:

fun Context.startActivity(clazz: Class<*>) {
    Intent(this, clazz).apply {
        startActivity(this)
    }
}

inline fun <reified T> Context.startActivity() {
    Intent(this, T::class.java).apply {
        startActivity(this)
    }
}

调用方:
context.startActivity(MainActivity::class.java)
context.startActivity<MainActivity>() // 第二种方式会简化一些
复制代码

3. 变型:协变 & 逆变 & 不变

变型(Variant)描述的是相同原始类型的不同参数化类型之间的关系。说起来有点绕,其实就是说:IntegerNumber的子类型,问你List<Integer>是不是List<Number>的子类型?

变型的种类具体分为三种:协变型 & 逆变型 & 不变型

  • 协变型(covariant): 子类型关系被保留
  • 逆变型(contravariant): 子类型关系被翻转
  • 不变型(invariant): 子类型关系被消除

在 Java 中,类型参数默认是不变型的,例如:

List<Number> l1;
List<Integer> l2 = new ArrayList<>();
l1 = l2; // compiler error
复制代码

相比之下,数组是支持协变型的:

Number[] nums;
Integer[] ints = new Integer[10]; 
nums = ints; // OK 协变,子类型关系被保留
复制代码

那么,当我们需要将List<Integer>类型的对象,赋值给List<Number>类型的引用时,应该怎么做呢?这个时候我们需要限定通配符

  • <? extends> 上界通配符

要想类型参数支持协变,需要使用上界通配符,例如:

List<? extends Number> l1;
List<Integer> l2 = new ArrayList<>();
l1 = l2; // OK
复制代码

但是这会引入一个编译时限制:不能调用参数包含类型参数 E 的方法,也不能设置类型参数的字段,简单来说,就是只能访问不能修改(非严格):

// ArrayList.java
public boolean add(E e) {
    ...
}

l1.add(1); // compiler error
复制代码
  • <? super> 下界通配符

要想类型参数支持逆变,需要使用下界通配符,例如:

List<? super Integer> l1;
List<Number> l2 = new ArrayList<>();
l1 = l2; // OK
复制代码

同样,这也会引入一个编译时限制,但是与协变相反:不能调用返回值为类型参数的方法,也不能访问类型参数的字段,简单来说,就是只能修改不能访问(非严格):

// ArrayList.java
public E get(int index) {
    ...
}

Integer i = l1.get(0); // compiler error
复制代码
  • <?> 无界通配符
其实很简单,很多资料其实都解释得过于复杂了。 < ?> 其实就是 的缩写。例如:
List<?> l1;
List<Integer> l2 = new ArrayList<>();
l1 = l2; // OK
复制代码

理解了这点,这个问题就很好回答了:

  • 问:List 与 List<?>有什么区别?

答:List 是原生类型,可以添加或访问元素,不具备编译期安全性,而 List 其实是 List的缩写,是协变型的(可引出协变型的特点与限制);从语义上,List 表明使用者清楚变量是类型安全的,而不是因为疏忽而使用了原生类型 List。

泛型代码的设计,应遵循PECS原则(Producer extends Consumer super):

  • 如果只需要获取元素,使用 <? extends T>
  • 如果只需要存储,使用<? super T>

举例:

// Collections.java public static void copy(List<? super T> dest, List<? extends T> src) { }

在 Kotlin 中,变型写法会有些不同,但是语义是完全一样的:

协变:
val l0: MutableList<*> 相当于MutableList<out Any?>
val l1: MutableList<out Number>
val l2 = ArrayList<Int>()
l0 = l2 // OK
l1 = l2 // OK
---------------------------------------------------
逆变:
val l1: MutableList<in Int>
val l2 = ArrayList<Number>()
l1 = l2 // OK
复制代码

另外,Kotlin 的in & out不仅仅可以用在类型实参上,还可以用在泛型类型声明的类型参数上。其实这是一种简便写法,表示类设计者知道类型参数在整个类上只能协变或逆变,避免在每个使用的地方增加,例如 Kotlin 的List被设计为不可修改的协变型:

public interface List<out E> : Collection<E> {
    ...
}
复制代码

注意:在 Java 中,只支持使用点变型,不支持 Kotlin 类似的声明点变型

小结一下:


4. 使用反射获取泛型信息

前面提到了,编译期会进行类型擦除,Code 属性中的类型信息会被擦除,但是在类常量池属性(Signature属性、LocalVariableTypeTable属性)中还保留着泛型信息,因此我们可以通过反射来获取这部分信息。

获取泛型类型实参:需要利用Type体系

4.1 获取泛型类 & 泛型接口声明

TypeVariable ParameterizedType GenericArrayType WildcardType

Gson TypeToken

Editting....


5. 总结

  • 应试建议
    • 1、第 1 节非常非常重点,着重记忆:泛型的本质和设计缘由、泛型擦除的三个步骤、限制和优点,已经总结得很精华了,希望能帮到你;
    • 2、着重理解变型(Variant)的概念,以及各种限定符的含义;
    • 3、Kotlin 相关的部分,作为知识积累和思路扩展为主,非应试重点。

参考资料

  • 《Kotlin实战》 (第9、10章)—— [俄] Dmitry Jemerov,Svetlana Isakova 著
  • 《Java编程思想》 (第19、20、23章)—— [美] Bruce Eckel 著
  • 《深入理解Java虚拟机(第3版本)》(第10章)—— 周志明 著

推荐阅读

感谢喜欢!你的点赞是对我最大的鼓励!欢迎关注彭旭锐的GitHub!