Kotlin编译器无法验证类的泛型类型

Question

fun <T: A()> getUtil(t: T): Util<T> = if (t is B) UtilB() else // ...

Kotlin编译器在这里发出警告（未检查的强制转换）：

fun <T: A()> getUtil(t: T): Util<T> = if (t is B) UtilB() as Util<T> else // ...

据我所知，Kotlin smart cast应该知道utilb()作为util 由t is b检查。

Java代码和编译器给出了完全相同的结果。

为了为每个实现获得正确的util类，我在伴生对象getUTIL上创建了一个函数，该函数基于泛型类型T的参数为每个实现返回正确的util类，该参数扩展了a:T:a，因此返回类型为util 。

但是，当我为A的每个派生类编写函数体时，使用Is b检查参数的类型，然后使用utilb()返回正确的util时，Kotlin编译器在返回点给了我一个错误，说utilb不属于util 类型，尽管它应该属于util 类型。

然后，我将utilb强制转换为util，这种方法起作用了，但给了我一个错误“unchecked cast”。根据我的理解，Kotlin smart cast应该能够确定它确实是一个有效的检查型cast（用检查的是b)，在运行快速测试后，它也是有效的...

我用Java重写了同样的代码，结果完全一样...

据我所知，这是Java/Kotlin泛型的一个限制。我想知道如何检查这个铸模。有可能吗？

abstract class A
class B : A()
class C : A()

abstract class Util<T : A> {
    abstract fun getName(): String
    companion object {
        fun <T : A> getUtil(t: T): Util<T> = when(t) {
            is B -> UtilB() as Util<T> // warning
            is C -> UtilC() // this event gives an error
            else -> throw IllegalArgumentException("No util for this class.")
        }
    }
}

class UtilB : Util<B>() {
    override fun getName(): String = "B"
}

class UtilC : Util<C>() {
    override fun getName(): String = "C"
}

fun main() {
    val b = B()
    val c = C()
    val utilB = Util.getUtil(b)
    val utilC = Util.getUtil(c)
    println(utilB.getName()) // prints B
    println(utilC.getName()) // prints C
}

Answer 1

以下是有效的修改版本：

abstract class A
class B : A()
class C : A()

abstract class Util<T : A> {
    abstract fun getName(): String
    companion object {
        fun <T : A> getUtil(t: T): Util<A> = when(t) {    // here return Util<A>
            is B -> UtilB()                               // No need cast
            is C -> UtilC()
            else -> throw IllegalArgumentException("No util for this class.")
        }
    }
}

class UtilB : Util<A>() {                   // Replace B by A
    override fun getName(): String = "B"
}

class UtilC : Util<A>() {                  // Replace C by A
    override fun getName(): String = "C"
}

fun main() {
    val b = B()
    val c = C()
    val utilB = Util.getUtil(b)
    val utilC = Util.getUtil(c)
    println(utilB.getName()) // prints B
    println(utilC.getName()) // prints C
}

但我不确定你走的路是对的。当我看到这个模式时，我看到了密封的类。

下面是一个使用密封类的实现：

sealed class AA {
    class BB : AA()
    class CC : AA()
}
sealed class AAU {
    abstract fun getName():String

    class BBU : AAU() {
        override fun getName()= "BB"
    }

    class CCU : AAU(){
        override fun getName()= "CC"
    }
}

fun getU(aa: AA) =
    when(aa) {
        is AA.BB -> AAU.BBU()
        is AA.CC -> AAU.CCU()
    }

fun main() {
   val bb = AA.BB()
   val cc = AA.CC()
   val bbu = getU(bb)
   val ccu = getU(cc)
   println(bbu.getName())
   println(ccu.getName())
}

sealed class AA {
    class BB : AA()
    class CC : AA()
}

fun getName(aa: AA) =
        when(aa) {
            is AA.BB -> "BB"
            is AA.CC -> "CC"
        }

fun main() {
    val bb = AA.BB()
    val cc = AA.CC()
    println(getName(bb))
    println(getName(cc))
}