Kotlin 在具有泛型的接口上调用方法

下面是我尝试做的一个非常简单的说明：

interface Event {
    fun value(): Int
}

class Event1: Event {
    override fun value() = 1
}

class Event2: Event {
    override fun value() = 2
}

interface EventConsumer<T> where T: Event {
    fun consume(event: T)
}

class Event1Consumer: EventConsumer<Event1> {
    override fun consume(event: Event1) {
        println(event.value())
    }
}

class Event2Consumer: EventConsumer<Event2> {
    override fun consume(event: Event2) {
        println(event.value())
    }
}

class EventManager {
    private val consumers: Map<KClass<*>, EventConsumer<*>> = mapOf(
            Event1::class to Event1Consumer(),
            Event2::class to Event2Consumer()
    )

    fun consume(event: Event) {
        val consumer = consumers[event::class]

        consumer?.consume(event)
    }
}

接口事件{
fun value（）：Int
}
类事件1：事件{
重写值（）=1
}
类事件2：事件{
覆盖值（）=2
}
接口EventConsumer，其中T:Event{
趣味消费（活动：T）
}
类Event1Consumer:EventConsumer{
覆盖乐趣消费（事件：Event1）{
println（event.value（））
}
}
类Event2Consumer:EventConsumer{
覆盖乐趣消费（事件：Event2）{
println（event.value（））
}
}
类事件管理器{
私有val消费者：Map=mapOf(
Event1:：类到Event1Consumer（），
Event2:：Event2Consumer（）的类
)
娱乐消费（事件：事件）{
val consumer=consumers[事件：：类]
消费者？消费（事件）
}
}

最后一个方法调用（consumer.consumer（））给了我一个编译器错误

Out投影类型“EventConsumer？”禁止使用“public” 抽象趣味消费（event:T）：在EventConsumer's中定义的单位

---

我知道Kotlin对泛型的要求比Java严格得多，这可能是它不起作用的原因，但是我如何正确地实现这样的东西呢？

既然您正在构建

消费者

映射，对正确的泛型EventConsumer类型进行未经检查的强制转换是安全的：

fun <T: Event> consume(event: T) {
    val consumer = consumers[event::class] as? EventConsumer<T>

    consumer?.consume(event)
}

趣味消费（事件：T）{
val consumer=consumers[event:：class]作为？EventConsumer
消费者？消费（事件）
}

aaah所以我一直缺少一个通用方法。。。这似乎解决了问题，谢谢！