Java 非泛型子类继承（实现）泛型超类（接口）

当非泛型子类具有父泛型超类/接口时，以下模型的好处是什么

interface Generic<Q: Number, R: Number> {

    fun calculate(input: Q): R
}

class ClassA: Generic<Int, Int> {

    override fun calculate(input: Int): Int {
        return input
    }
}

class ClassB: Generic<Float, Float> {

    override fun calculate(input: Float): Float {
        return input
    }
}

通用接口{
乐趣计算（输入：Q）：R
}
A类：通用{
覆盖乐趣计算（输入：Int）：Int{
返回输入
}
}
B类：泛型{
覆盖乐趣计算（输入：浮点）：浮点{
返回输入
}
}

多态性无论如何都不可用（需要使用模式匹配进行显式转换）。在没有继承/实现的情况下也可以得到相同的结果：

fun main() {
    val classA: Generic<Int, Int> = ClassA()
    val classB: Generic<Float, Float> = ClassB()
    val inputs: List<Number> = listOf(1, 1.1, 2, 2.2)

    for (input in inputs) {
        when (input) {
            is Int -> classA.calculate(input)
            is Float -> classB.calculate(input)
        }
    }
}

fun main（）{
val classA:Generic=classA（）
val classB:Generic=classB（）
val输入：列表=列表（1,1.1,2,2.2）
用于（输入中的输入）{
何时（输入）{
is Int->classA.calculate（输入）
是Float->classB.calculate（输入）
}
}
}

根据您当前的设置，我认为使用

通用接口并不是完全必要的。但是，当您扩展代码时，我认为它会有所帮助

现在使用它的一个优点是，您现在有两个相似的类，它们具有一致的方法名和相似的方法签名。通过继承
Generic
，它可以通过键入
caluclate
而不是
calculate
来保存打字错误。有些人可能不认为这是一个有效的理由，但我认为使用这种接口使您的代码在这种情况下更加一致。
使用
Generic
的优势在于您实际需要引用它

interface Calculator<T : Number, K : Generic<T>> {
    fun calculate(generic: K): T
}
class DefaultCalculator...

接口计算器{
乐趣计算（通用：K）：T
}
类默认计算器。。。

上面的代码只是一个示例，在您的用例中可能不实用，但是如果您认为将来可能需要它，现在使用
Generic
接口可能会节省一些重构工作。
此模型的主要好处是，您只需创建一个
Generic
接口，而不必创建
IntCalculator
、
FloatCalculator
和
Calculator
接口。另外，我假设您，因此您必须创建
Generic
或
IntCalculator
，
FloatCalculator
和
Calculator
。