从 kotlin 到 Java，关于 kotlin 泛型的问题

Question

我正在将代码从 java 迁移到 kotlin，但泛型存在一些问题。

这是一个解释我的疑惑的例子：

import java.util.*
import kotlin.collections.HashMap

interface MyGenerics<T>{
  fun produce():T
  fun publish(toPublish:T):String
}

class MyImplementation:MyGenerics<Boolean>{

  override fun produce(): Boolean {
    return true
  }

  override fun publish(toPublish: Boolean): String {
    return "test"
  }

}

class RegistrationClass{

  private val workers = HashMap<String, Vector<MyGenerics<Any>>>()

  fun register(type: String, worker: MyGenerics<Any>) {
    if (!workers.containsKey(type)) workers[type] = Vector()
      workers[type]!!.add(worker)


   //usage example
   for (workers in workers[type]!!){
     val product = workers.produce()
     workers.publish(product)
    }
  }

}

fun main() {
   val registrationClass = RegistrationClass()
   registrationClass.register("MyTest", MyImplementation()) //error kotlin implementation

   val javaRegistrationClass = JavaRegistrationClass()
   javaRegistrationClass.register("MyNewTest", MyImplementation()) //java implementation

}

为什么我会出错

> registrationClass.register("MyTest", MyImplementation()) //error
> kotlin implementation

而不是：

javaRegistrationClass.register("MyNewTest", MyImplementation()) //java implementation

这是 JavaRestristrationClass：

class JavaRegistrationClass{

    private HashMap workers = new HashMap<String, Vector<MyOtherTest>>();

    public void register(String type, MyGenerics worker) {
        //do something
    }

}

我已经阅读了这个https://stackoverflow.com/a/65534086/3681634 的答案，但我仍然不明白

Answer 1

在 java 代码中，您使用原始类型 (MyGenerics)，它是不安全的（因此未添加到 Kotlin）并且仍然存在于 java 中，只是为了与 Java 5 之前编写的代码向后兼容。

MyGenerics<Any> 你使用的类型不是它的等价物。 您需要提供公平的泛型类型MyGenerics<T>（并使您的方法泛型），或者使用MyGenerics<*> 类型。

由于您故意在一个通用集合中混合不同类型的元素，因此在所有情况下都不可避免地会出现未经检查的强制转换。

选项 1（使用MyGenerics<T>）：

class RegistrationClass {
    private val workers = HashMap<String, Vector<MyGenerics<Any>>>()

    fun <T> register(type: String, worker: MyGenerics<T>) {
        val workersOfType = workers.getOrPut(type) { Vector() }
        @Suppress("UNCHECKED_CAST")
        workersOfType.add(worker as MyGenerics<Any>)

        //usage example
        workersOfType.forEach { it.publish(it.produce()) }
    }
}

选项 2（使用MyGenerics<*>）：

class RegistrationClass {
    private val workers = HashMap<String, Vector<MyGenerics<Any>>>()

    fun register(type: String, worker: MyGenerics<*>) {
        val workersOfType = workers.getOrPut(type) { Vector() }
        @Suppress("UNCHECKED_CAST")
        workersOfType.add(worker as MyGenerics<Any>)

        //usage example
        workersOfType.forEach { it.publish(it.produce()) }
    }
}

您也可以更改workers 集合的类型（正如@Tenfour04 在 cmets 中建议的那样）：

选项 1.1/2.1（使用 MyGenerics<T>/MyGenerics<*> 和 Vector<MyGenerics<*>>）：

class RegistrationClass {
    private val workers = HashMap<String, Vector<MyGenerics<*>>>()

    fun <T> register(type: String, worker: MyGenerics<T>) { 
//  fun register(type: String, worker: MyGenerics<*>) { //also possible
        val workersOfType = workers.getOrPut(type) { Vector() }
        workersOfType.add(worker)

        //usage example
        workersOfType.forEach {
            @Suppress("UNCHECKED_CAST")
            it as MyGenerics<Any>
            it.publish(it.produce())
        }
    }
}

更新

实际上，可以避免使用选项 1.1/2.1 进行强制转换，如果您可以隐藏操作，在接口内显示通用集合元素的类型（正如 @al3c 在 cmets 中建议的那样）：

interface MyGenerics<T> {
    fun produce(): T
    fun publish(toPublish: T): String
    fun produceAndPublish() = publish(produce())
}

class RegistrationClass {
    private val workers = HashMap<String, Vector<MyGenerics<*>>>()

    fun <T> register(type: String, worker: MyGenerics<T>) { 
//  fun register(type: String, worker: MyGenerics<*>) { //also possible
        val workersOfType = workers.getOrPut(type) { Vector() }
        workersOfType.add(worker)

        //usage example
        workersOfType.forEach { it.produceAndPublish() }
    }
}

Answer 2

我是这样做的：

class RegistrationClass{

  private val bookOrder = HashMap<String, Vector<MyGenerics<*>>>()

  fun register(type: String, worker: MyGenerics<*>) {
    if (!bookOrder.containsKey(type)) bookOrder[type] = Vector()
    bookOrder[type]!!.add(worker)
  }

  fun runExample(type:String){
    //usage example
    for (workers in bookOrder[type]!!){
      val product = workers.produce()
      @Suppress("UNCHECKED_CAST")
      (workers as MyGenerics<Any?>).publish(product)
    }
  }

}

fun main() {
  val registrationClass = RegistrationClass()
  registrationClass.register("MyTest", MyImplementation())
}

但我想知道： 有没有办法不使用未经检查的演员表？