kotlin - 为什么表达式 objectOfTypeT::class 的类型是 KClass？

Question

假设我们有通用函数:

fun <T: Any> foo(o: T) {
    o::class
}

o::class的类型是 KClass<out T> .为什么有出方差注释，为什么没有 KClass<out Any> (因为 T 的删除是 Any )

这个出方差注释搞砸了我漂亮的反射代码

编辑:
挖了一会，发现kotlin依赖 Object::getClass获取 Class创建 KClass ，实际的创建代码有一个类似 fun <T: Any> create(jClass: Class<T>): KClass<T> 的签名.然而，这导致了另一个问题。 o::class应该是 KClass<Any> 类型因为 jClass该创建方法的参数应为 Class<Object> 类型, 由于静态类型的删除 T只是 Any (或 Object ，映射到 JVM 上)。

Answer 1

为什么有出方差注释？

这是 Bounded Class Reference 的预期行为在 Kotlin 1.1 中。

我们知道子类的实例可以分配给父类(super class)，例如:

val long:Number = 1L;
val int:Number = 1;

我们也知道泛型继承不像类继承，例如:

val long:KClass<Long> = Long::class;
val number:KClass<Number> = long;
//                           ^
// can't be compiled, required KClass<Number> but found KClass<Number>

所以我们使用 Generic Type Projection 来编译代码如下:

val number:KClass<out Number>  = long;

简而言之，父类(super class)( Number)的变量可以分配给它的任何子类( Long、 Int、 Double 和 .etc)的实例，但是当得到 KClass来自 Number 的引用引用它应该是返回一个 KClass<out Number>而不是 KClass<Number> , 因为 KClass<Int>不是 KClass<Number> 的子类型.

同样的规则也适用于 java，例如:

Number number = 1L;

Class<? extends Number> type = number.getClass();

为什么不是 KClass(因为 T 的删除是 Any)？

因为您的方法使用泛型参数 T , 但是 java.lang.Object#getClass根本不使用任何泛型参数，它的返回类型是 Class<? extends Object> .

但是， T#javaClass属性采用通用参数 T你可以看到下面的代码 kotin 转换了 Class<?>到 Class<T> .所以 Upper Bounded Wildcard的 o::class在 foo方法是 KClass<? extends T>而不是 KClass<? extends Object>在 java 。

public inline val <T: Any> T.javaClass : Class<T>
   @Suppress("UsePropertyAccessSyntax")
   get() = (this as java.lang.Object).getClass()   as Class<T>
   // force to casting a Class<?> to a Class<T> ---^

一个 KClass<? extends T>是 KClass<?> 的子类型, 根据 LISP principle您不能将父类(super class)实例分配给子类类型。

fun <T : Any> foo(value: T) {
    val type: Class<out T> = (value as java.lang.Object).getClass();
    //   ^
    // Compilation Error:
    // you can't assign Class<? extends Object> to a Class<? extends T>
}

您还可以看到方法通用签名如下:

val noneGenericParametersMethod= Object::class.java.getDeclaredMethod("getClass")!!
val genericParametersMethod by lazy {
    val it = object {
        fun <T : Any> foo(): Class<out T> = TODO();
    };
    return@lazy it.javaClass.getDeclaredMethod("foo")!!;
}

println(genericParametersMethod.toGenericString())
//      ^--- its return type is java.lang.Class<? extends T>

println(noneGenericParametersMethod.toGenericString())
//      ^--- its return type is java.lang.Class<? extends Object>

基于以上，表达式 o::class实际上返回一个 Raw Type KClass而不是参数化类型 KClass<out T> , 和 Raw Type可以分配给任何 Parameterized Type , 但是，kotlin 没有 Raw Type ，所以 kotlin 编译器缩小了原始类型 KClass进入参数化类型 KClass<out T> ，就像狭窄的 List<*>到 Iterable<*> . Raw Type 的示例在java中:

Box rawBox = new Box();           // rawBox is a raw type of Box<T>
Box<Integer> intBox = rawBox;     // warning: unchecked conversion

为什么 java 不能将 T.getClass() 分配给 Class<？扩展 T>?

如果您深入了解 java.lang.Object#getClass 的文档方法，你会发现结果如下:

The actual result type is Class<? extends |X|> where |X| is the erasure of the static type of the expression on which getClass is called.

“ 静态类型的删除 ”:表示 |X|是有界类型而不是运行时的实际泛型参数类型，例如:

// Object.getClass() using the bounded static type `Number`
//         v    
<T extends Number> Class<? extends Number> foo(T value){
    return value.getClass();
}