generics - KFunction1 中的 kotlin 泛型

Question

假设，您有两个类 TestA 和 TestB。假设 TestA 扩展了 TestB:

public class TestB {
    private int intProp;
    public int getIntProp() {
        return intProp;
    }
    public void setIntProp(int intProp) {
        this.intProp = intProp;
    }
}


public class TestA extends TestB {
    private String strProp;
    public String getStrProp() {
        return strProp;
    }
    public void setStrProp(String strProp) {
        this.strProp = strProp;
    }
}

现在我创建下一行代码:

var getter1: KFunction1<TestA, Int> = TestA::getIntProp

如您所见，我从 TestB 的 TestA 类方法访问:TestA::getIntProp
所以结果是带有通用参数的 KFunction1 实例 < TestA, Int >

现在我尝试创建下一行代码

var getter2: KFunction1<TestA, Int> = TestB::getIntProp

它也可以工作和编译，而我预计会有编译错误

Answer 1

这是generics variance in Kotlin ，其目的是将类型安全的层次结构强加于具有类层次结构本身中的参数的泛型类。
类(class)KFunction1具有定义为 <in P1, out R> 的通用参数, P1与 in修饰符和 R与 out修饰符。这意味着将有:

关于 的逆变P1由 in 介绍修饰符。
任意 KFunction1<PSuper, R>将是 KFunction1<P, R> 的子类型如果 PSuper是 P 的父类(super class)型.但是会增加限制，即P1只能作为(传入)KFunction1 的参数出现的成员。

上的协方差R由 out 介绍修饰符。
任意 KFunction1<P, RSub>将是 KFunction1<P, R> 的子类型如果 RSub是 R 的子类型.在这里R将受到限制:它只能用作 KFunction1 的返回值(传递出去)的成员。

因此，您将能够分配 KFunction1<PSuper, RSub>到 KFunction1<P, R> 类型的变量.
这对 KFunction1 有意义，因为任何接收类型为 PSuper 的参数的函数也可以接收 P 的实例(但反之亦然)，以及任何返回 RSub 实例的函数同时返回 R 的实例(但反之则不然)。

您可以简单地编写一个示例来显示此行为:

class Invariant<T>  {
    fun f(i: Int): T { throw Exception() } // OK
    fun f(t: T): Int { throw Exception() } // OK
}

class Contravariant<in T> {
    fun f(i: Int): T { throw Exception() } // error, T cannot be returned
    fun f(t: T): Int { throw Exception() } // OK, T is parameter type
}

class Covariant<out T> {
    fun f(i: Int): T { throw Exception() } // OK, T is returned
    fun f(t: T): Int { throw Exception() } // error, T cannnot be parameter type
}

open class Base
class Derived: Base()

val i1: Invariant<Base> = Invariant<Derived>() // error
val i2: Invariant<Derived> = Invariant<Base>() // error

val n1: Contravariant<Base> = Contravariant<Derived>() // error
val n2: Contravariant<Derived> = Contravariant<Base>() // OK

val v1: Covariant<Base> = Covariant<Derived>() // OK
val v2: Covariant<Derived> = Covariant<Base>() // error