带具体类型参数的函数重写问题：为何提示未重写任何内容

嘿，这个问题我之前踩过坑！咱们先拆解下为啥会出现这个报错，再给你几个实用的替代方案，完美实现你想要的ConcretRun类的run方法接收ConcretClasOne类型参数的需求。

为啥会报错？ #

首先得明确Kotlin的方法重写规则：重写的方法必须和父类方法的签名完全匹配（或者满足逆变参数的要求，但这里你用的是更具体的参数类型，属于协变，不符合规则）。

举个例子，假设你的代码结构是这样的：

// 抽象父类
abstract class AbstractClass

// 具体子类
class ConcretClasOne : AbstractClass()

// 抽象Runner类
abstract class AbstractRunner {
    abstract fun run(obj: AbstractClass)
}

// 你的实现类
class ConcretRun : AbstractRunner() {
    // 这里会报“run overrides nothing”
    fun run(obj: ConcretClasOne) {
        // 你的逻辑
    }
}

这个run方法的参数是ConcretClasOne，而父类AbstractRunner的run参数是AbstractClass——Kotlin不认为这是重写，而是一个全新的方法，所以会提示“run overrides nothing”。这背后是遵循里氏替换原则：如果用父类AbstractRunner的引用指向ConcretRun对象，调用run时传入其他AbstractClass的子类（比如ConcretClasTwo），你的方法根本处理不了，所以这种写法不被允许。

靠谱的替代方案 #

方案一：泛型约束（最推荐，类型安全） #

把抽象AbstractRunner改成泛型类，通过泛型约束限定参数类型，这样具体实现类可以指定自己要处理的具体类型：

abstract class AbstractClass
class ConcretClasOne : AbstractClass() {
    fun concreteMethod() = println("我是ConcretClasOne的特有方法")
}

// 抽象类添加泛型，约束T必须是AbstractClass的子类
abstract class AbstractRunner<T : AbstractClass> {
    abstract fun run(obj: T)
}

// 具体实现类指定T为ConcretClasOne
class ConcretRun : AbstractRunner<ConcretClasOne>() {
    override fun run(obj: ConcretClasOne) {
        // 直接安全调用ConcretClasOne的特有方法
        obj.concreteMethod()
    }
}

这个方案是编译时类型安全的，完全符合你的需求，也是Kotlin中处理这类场景的标准做法。

方案二：运行时类型检查（适合不想用泛型的场景） #

如果不想改动抽象类的结构，可以在重写的方法里做类型检查，确保传入的是ConcretClasOne，再智能转换类型：

abstract class AbstractClass
class ConcretClasOne : AbstractClass() {
    fun concreteMethod() = println("我是ConcretClasOne的特有方法")
}

abstract class AbstractRunner {
    abstract fun run(obj: AbstractClass)
}

class ConcretRun : AbstractRunner() {
    override fun run(obj: AbstractClass) {
        // 检查类型，不符合就抛出异常
        require(obj is ConcretClasOne) { "必须传入ConcretClasOne类型的对象，当前是${obj::class.simpleName}" }
        // 这里obj会被智能转换为ConcretClasOne
        obj.concreteMethod()
    }
}

缺点是需要运行时检查，不是编译时安全的，如果传入其他子类会抛出异常，但胜在不需要修改抽象类的结构。

方案三：接口+泛型（灵活扩展） #

如果AbstractRunner可以改成接口，用泛型接口的方式也能实现同样的效果，适合需要多实现的场景：

abstract class AbstractClass
class ConcretClasOne : AbstractClass() {
    fun concreteMethod() = println("我是ConcretClasOne的特有方法")
}

interface Runner<T : AbstractClass> {
    fun run(obj: T)
}

class ConcretRun : Runner<ConcretClasOne> {
    override fun run(obj: ConcretClasOne) {
        obj.concreteMethod()
    }
}

思路和泛型类一致，只是把抽象类换成了接口，灵活性更高。

内容的提问来源于stack exchange，提问作者oriaj