java - 为什么将KClass声明为KClass <T:Any>而不是KClass <T>，以便type参数可以为空

我正在尝试在Kotlin中基于 Java数组实现检查的 Stack<E>。但是我将KClass与我的通用参数类型<E>一起使用时存在问题，它允许空值。

interface Stack<E> {
    fun push(elem: E)
    fun pop(): E
}

class CheckedStack<E>(elementType: Class<E>, size: Int) : Stack<E> {

    companion object {
        inline fun <reified E> create(size: Int): CheckedStack<E> {
            //**compile error here**
            return CheckedStack(E::class.javaObjectType, size)
        }
    }

    @Suppress("UNCHECKED_CAST")
    private val array: Array<E?> = java.lang.reflect.Array.newInstance(elementType, size) as Array<E?>
    private var index: Int = -1

    override fun push(elem: E) {
        check(index < array.size - 1)
        array[++index] = elem
    }

    override fun pop(): E {
        check(index >= 0);
        @Suppress("UNCHECKED_CAST")
        return array[index--] as E
    }
}

我希望这段代码可以这样工作:

fun main() {
    val intStack = CheckedStack.create<Int>(12) // Stack must store only Integer.class values
    intStack.push(1); //[1]
    intStack.push(2); //[1, 2]

    val stackOfAny: Stack<Any?> = intStack as Stack<Any?>;
    stackOfAny.push("str") // There should be a runtime error
}

但是我有编译错误

Error:(39, 42) Kotlin: Type parameter bound for T in val <T : Any> KClass<T>.javaObjectType: Class<T>
 is not satisfied: inferred type E is not a subtype of Any

为了修复它，我需要绑定(bind)类型参数<E : Any>，但是我需要使堆栈能够使用可空值<T : Any?>。如何解决？
为什么将KClass声明为KClass<T : Any>而不是KClass<T : Any?>？
UPD:如果使用E::class.java代替E::class.javaObjectType，则可以使用
因为属性val <T> KClass<T>.java: Class<T>具有注释<T>的类型param @Suppress("UPPER_BOUND_VIOLATED")。
但是属性val <T : Any> KClass<T>.javaObjectType: Class<T>具有类型<T : Any>。
就我而言，Kotlin将Int编译为Integer.class而不是int(就我而言)。但是我不确定它是否也能正常工作。

最佳答案

可空类型本身不是类，因此它们没有类对象。这就是KClass的type参数具有Any上限的原因。

您可以在可为空的化类型上调用::class.java，但是它将被评估为与对相应非null类型的相同调用相同的类对象。因此，如果将E::class.javaObjectType替换为E::class.java，则将在运行时检查元素的类型，但不会执行空检查。

如果需要空检查，则可以自己添加它们。我还建议将数组创建移至工厂方法。这是您可以执行的操作:

class CheckedStack<E>(private val array: Array<E?>, private val isNullable: Boolean) : Stack<E> {

    companion object {
        // This method invocation looks like constructor invocation
        inline operator fun <reified E> invoke(size: Int): CheckedStack<E> {
            return CheckedStack(arrayOfNulls(size), null is E)
        }
    }

    private var index: Int = -1

    override fun push(elem: E) {
        if (!isNullable) elem!!
        check(index < array.size - 1)
        array[++index] = elem
    }

    override fun pop(): E {
        check(index >= 0)
        @Suppress("UNCHECKED_CAST")
        return array[index--] as E
    }
}