Kotlin枚举类无法继承的替代方案？多枚举需复用通用项

问题背景 #

定义了两个Kotlin枚举类As和Bs，二者均包含Unknown("null")通用枚举项。原本计划通过上层枚举类Upper提取该通用项并让As、Bs继承，再以Upper作为函数参数进行类型判断，但Kotlin不支持枚举类继承，目前只能通过重载函数分别接收As和Bs类型参数，希望找到更优的处理方式。

原枚举代码：

enum class As(val value: String) {
    A1("a1"),
    A2("a2"),
    A3("a3"),
    Unknown("null")
}

enum class Bs(val value: String) {
    B1("b1"),
    B2("b2"),
    Unknown("null")
}

可行解决方案 #

方案一：用接口统一行为

定义包含通用属性和方法的接口，让两个枚举实现该接口，即可用接口作为函数参数统一处理。

// 定义通用接口
interface HasUnknown {
    val value: String
    // 通用判断逻辑
    fun isUnknown(): Boolean = value == "null"
}

// 让枚举实现接口
enum class As(override val value: String) : HasUnknown {
    A1("a1"),
    A2("a2"),
    A3("a3"),
    Unknown("null")
}

enum class Bs(override val value: String) : HasUnknown {
    B1("b1"),
    B2("b2"),
    Unknown("null")
}

统一参数的函数写法：

@Composable
fun aFunc(item: HasUnknown, /* 其他参数 */) {
    // 分类型处理特有逻辑
    when (item) {
        is As -> {
            when (item) {
                As.A1 -> {}
                As.A2 -> {}
                As.A3 -> {}
                As.Unknown -> {}
            }
        }
        is Bs -> {
            when (item) {
                Bs.B1 -> {}
                Bs.B2 -> {}
                Bs.Unknown -> {}
            }
        }
    }
    // 复用通用逻辑
    if (item.isUnknown()) {
        // 统一处理Unknown的逻辑
    }
}

方案二：用扩展函数复用通用逻辑

如果不需要统一参数类型，可将通用逻辑（如Unknown判断）提取到扩展函数中，减少重载函数的代码重复。

// 为每个枚举添加扩展函数
fun As.isUnknown(): Boolean = this == As.Unknown
fun Bs.isUnknown(): Boolean = this == Bs.Unknown

// 或者通过接口统一扩展
interface HasValue { val value: String }
enum class As(override val value: String) : HasValue { /* 原有定义 */ }
enum class Bs(override val value: String) : HasValue { /* 原有定义 */ }

fun HasValue.isUnknown(): Boolean = value == "null"

重载函数中复用通用逻辑：

@Composable
fun aFunc(a: As, /* 其他参数 */) {
    handleUnknown(a)
    // As特有处理逻辑
}

@Composable
fun aFunc(b: Bs, /* 其他参数 */) {
    handleUnknown(b)
    // Bs特有处理逻辑
}

@Composable
private fun handleUnknown(item: HasValue) {
    if (item.isUnknown()) {
        // 统一的Unknown处理逻辑
    }
}

方案三：用密封类封装枚举（重构结构）

若允许调整原有枚举的结构，可将As和Bs嵌套到密封类中，这样就能用密封类作为函数参数，实现你期望的类型判断逻辑。

sealed class Upper(val value: String) {
    enum class As(override val value: String) : Upper(value) {
        A1("a1"),
        A2("a2"),
        A3("a3"),
        Unknown("null")
    }

    enum class Bs(override val value: String) : Upper(value) {
        B1("b1"),
        B2("b2"),
        Unknown("null")
    }
}

符合期望的函数写法：

@Composable
fun aFunc(upper: Upper, /* 其他参数 */) {
    when (upper) {
        is Upper.As -> {
            when (upper) {
                Upper.As.A1 -> {}
                Upper.As.A2 -> {}
                Upper.As.A3 -> {}
                Upper.As.Unknown -> {}
            }
        }
        is Upper.Bs -> {
            when (upper) {
                Upper.Bs.B1 -> {}
                Upper.Bs.B2 -> {}
                Upper.Bs.Unknown -> {}
            }
        }
    }
}

这个方案完全匹配你最初期望的类型判断方式，但需要重构原有枚举的定义结构。

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