Kotlin中如何实现静态多态？伴生对象常量访问问题求解

现有密封接口Animal及其多个实现类，所有实现类都在伴生对象中定义了编译时常量nickname：

sealed interface Animal {
    // 如何约束统一的nickname访问？
}

class Canidae: Animal {
    companion object {
        const val nickname = "dog"
    }
}

class Felidae: Animal {
    companion object {
        const val nickname = "cat"
    }
}

// 更多实现类...

希望编写如下扩展函数，但代码无法编译（无法直接访问T.nickname和this.nickname）：

inline fun<reified T: Animal, R> Animal.doSomething(f: (T) -> R): R =
    if (this is T) {
        f(this)
    } else {
        error("it's not a ${T.nickname}, it's a ${this.nickname}!") // 编译失败
    }

已尝试反射遍历Animal派生类的方案，但存在运行时开销，且无法在对应类的定义处维护nickname，寻求更优雅的实现方式。

方案1：伴生对象实现统一接口+密封类型分支 #

首先定义一个接口约束伴生对象的nickname：

interface HasNickname {
    val nickname: String
}

修改Animal实现类，让伴生对象实现该接口：

sealed interface Animal

class Canidae: Animal {
    companion object : HasNickname {
        const val nickname = "dog"
        override val nickname: String get() = nickname
    }
}

class Felidae: Animal {
    companion object : HasNickname {
        const val nickname = "cat"
        override val nickname: String get() = nickname
    }
}

添加Animal的扩展属性获取当前实例的nickname（利用密封接口的编译时检查）：

val Animal.nickname: String
    get() = when(this) {
        is Canidae -> Canidae.nickname
        is Felidae -> Felidae.nickname
        // 密封接口会强制覆盖所有实现类，避免遗漏
    }

最终实现doSomething函数：

inline fun<reified T: Animal, R> Animal.doSomething(f: (T) -> R): R {
    val targetNickname = (T::class.companionObjectInstance as? HasNickname)?.nickname
        ?: error("${T::class.simpleName}未实现HasNickname接口")
    
    return if (this is T) {
        f(this)
    } else {
        error("it's not a $targetNickname, it's a ${this.nickname}!")
    }
}

优势：

• nickname仍在对应类的伴生对象中维护，符合单一职责
• 密封接口的when表达式强制覆盖所有实现类，无遗漏风险
• 仅一次轻量反射获取伴生对象，因函数是inline reified，开销极小

方案2：将nickname作为接口成员属性 #

直接在Animal接口中定义nickname属性，实现类以编译时常量重写：

sealed interface Animal {
    val nickname: String
}

class Canidae: Animal {
    override val nickname: String = "dog" // 编译时会优化为常量
}

class Felidae: Animal {
    override val nickname: String = "cat"
}

实现doSomething函数：

inline fun<reified T: Animal, R> Animal.doSomething(f: (T) -> R): R {
    // 通过反射获取T的nickname常量值，开销极低
    val targetNickname = T::class.memberProperties
        .first { it.name == "nickname" }
        .get(T::class.objectInstance) as String
    
    return if (this is T) {
        f(this)
    } else {
        error("it's not a $targetNickname, it's a ${this.nickname}!")
    }
}

优势：

• 代码简洁，无需伴生对象
• nickname作为接口成员，约束性更强
• 编译时常量优化后，反射获取的开销可忽略

方案3：注解+编译时代码生成（零运行时开销） #

定义Nickname注解标记类的昵称：

@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.SOURCE)
annotation class Nickname(val value: String)

给Animal实现类添加注解：

@Nickname("dog")
class Canidae: Animal

@Nickname("cat")
class Felidae: Animal

通过Kotlin注解处理器（KAPT）编译时生成昵称映射类（示例生成代码）：

object AnimalNicknames {
    val mappings = mapOf(
        Canidae::class to "dog",
        Felidae::class to "cat"
    )
}

实现doSomething函数：

inline fun<reified T: Animal, R> Animal.doSomething(f: (T) -> R): R {
    val targetNickname = AnimalNicknames.mappings[T::class]
        ?: error("${T::class.simpleName}未标记Nickname注解")
    val currentNickname = AnimalNicknames.mappings[this::class]
        ?: error("${this::class.simpleName}未标记Nickname注解")
    
    return if (this is T) {
        f(this)
    } else {
        error("it's not a $targetNickname, it's a $currentNickname!")
    }
}

优势：

• 完全无运行时反射开销
• nickname通过注解维护在类定义处，管理方便
• 编译时生成映射，类型安全且性能最优

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