Generics Kotlin通用工厂动态铸造

我要创建具有通用参数的对象工厂：

interface Foo<T> {
    fun buzz(param: T)
}

我的

buzz

方法拒绝任何参数（希望

Nothing

作为类型）

因此，我创建了另一个带有类型的映射

val classMap = mapOf<String, KClass<*>>(
    Pair(firstKey, FooImpl1::class),
    Pair(secKey, FooImpl2::class)
)

val paramClassMap = mapOf<String, KClass<*>>(
    Pair(firstKey, String::class),
    Pair(secKey, Int::class)
)

我还尝试使用

标记

类型，但对eather没有帮助：

val classMap = mapOf<String, Type>(
    Pair(firstKey, object: TypeToken<FooImpl1>() {}.type),
    Pair(secKey, object: TypeToken<FooImpl1>() {}.type)
)

val classMap=mapOf(
配对（firstKey，对象：TypeToken（）{}.type），
配对（secKey，对象：TypeToken（）{}.type）
)

---

你知道如何正确地投下它吗？或者一些“不同的方法”的想法？

恐怕你只需要做一些未经检查的演员

interface Foo<T> {
    fun buzz(param: T)
}

class FooImpl1 : Foo<String> {
    override fun buzz(param: String) {
        println(param)
    }
}

class FooImpl2 : Foo<Int> {
    override fun buzz(param: Int) {
        println(param)
    }
}

val implementationMap = mapOf<String, Foo<*>>(
        Pair("firstKey", FooImpl1()),
        Pair("secKey", FooImpl2())
)

val paramMap = mapOf<String, Any>(
        Pair("firstKey", "String param"),
        Pair("secKey", 12)
)


fun main() {
    @Suppress("UNCHECKED_CAST")
    val imp = implementationMap["firstKey"] as Foo<Any?>
    val param = paramMap["firstKey"]
    imp.buzz(param)
}

接口Foo{
有趣的嗡嗡声（参数：T）
}
类FooImpl1:Foo{
覆盖有趣的嗡嗡声（参数：字符串）{
println（参数）
}
}
第2类：Foo{
覆盖有趣的嗡嗡声（参数：Int）{
println（参数）
}
}
val implementationMap=mapOf(
配对（“firstKey”，FooImpl1（）），
配对（“secKey”，FooImpl2（））
)
val paramMap=mapOf(
配对（“第一个键”、“字符串参数”），
配对（“secKey”，12）
)
主要内容（）{
@抑制（“未选中的_CAST”）
val imp=implementationMap[“firstKey”]作为Foo
val param=paramMap[“firstKey”]
imp.buzz（参数）
}

好吧，如果你能把它们组合在一起

class FooWithParam<T>(foo: Foo<T>, param: T) {
    fun doBuzz() = foo.buzz(param)
}

val fooWithParamMap = mapOf<String, FooWithParam<*>>(
    Pair(firstKey, FooWithParam(FooImpl1(), "String param"),
    Pair(secKey, FooWithParam(FooImpl2(), 12))
)

implementationMap[firstKey].doBuzz()

class-FooWithParam（foo:foo，param:T）{
fun doBuzz（）=foo.buzz（参数）
}
val fooWithParamMap=mapOf(
配对（firstKey，FooWithParam（FooImpl1（），“字符串参数”），
配对（secKey，FooWithParam（FooImpl2（），12））
)
implementationMap[firstKey].doBuzz（）

val classMap = mapOf<String, KClass<*>>(
    Pair(firstKey, FooImpl1::class),
    Pair(secKey, FooImpl2::class)
)

val paramClassMap = mapOf<String, KClass<*>>(
    Pair(firstKey, String::class),
    Pair(secKey, Int::class)
)

implementationMap.getValue(firstKey)
    .cast < classMap.getValue(firstKey) > () // not possible
    .buzz(
        paramMap.getValue(firstKey)
        .cast < paramClassMap.getValue(firstKey) > () // not possible
    )

(implementationMap.getValue(firstKey) // FooImpl1
    /*not possible */ as classMap.getValue(firstKey)) // (FooImpl1::class)
    .buzz(
        paramMap.getValue(firstKey) // String
        /*not possible */ as paramClassMap.getValue(firstKey)) // (String::class)

val classMap = mapOf<String, Type>(
    Pair(firstKey, object: TypeToken<FooImpl1>() {}.type),
    Pair(secKey, object: TypeToken<FooImpl1>() {}.type)
)

interface Foo<T> {
    fun buzz(param: T)
}

class FooImpl1 : Foo<String> {
    override fun buzz(param: String) {
        println(param)
    }
}

class FooImpl2 : Foo<Int> {
    override fun buzz(param: Int) {
        println(param)
    }
}

val implementationMap = mapOf<String, Foo<*>>(
        Pair("firstKey", FooImpl1()),
        Pair("secKey", FooImpl2())
)

val paramMap = mapOf<String, Any>(
        Pair("firstKey", "String param"),
        Pair("secKey", 12)
)


fun main() {
    @Suppress("UNCHECKED_CAST")
    val imp = implementationMap["firstKey"] as Foo<Any?>
    val param = paramMap["firstKey"]
    imp.buzz(param)
}

class FooWithParam<T>(foo: Foo<T>, param: T) {
    fun doBuzz() = foo.buzz(param)
}

val fooWithParamMap = mapOf<String, FooWithParam<*>>(
    Pair(firstKey, FooWithParam(FooImpl1(), "String param"),
    Pair(secKey, FooWithParam(FooImpl2(), 12))
)

implementationMap[firstKey].doBuzz()