Kotlin场景下sealed class/Enum/HashMap选型？智能转换问题求解

核心思路是将执行逻辑统一封装到密封类的抽象接口中，让枚举仅作为标识和容器，调用方无需关心具体函数类型，同时保留枚举的遍历特性，避免手动强转。

步骤1：重构密封类，提供统一执行入口 #

将普通函数和挂起函数的执行逻辑统一到密封类的抽象方法中，利用挂起函数可兼容普通函数执行的特性（普通函数可直接在挂起上下文调用）：

import kotlinx.coroutines.runBlocking

sealed class Executable {
    // 同步执行入口（处理普通函数，挂起函数通过runBlocking适配同步场景）
    abstract fun executeSync(): Boolean
    // 异步挂起执行入口（兼容所有函数类型）
    abstract suspend fun executeAsync(): Boolean
}

// 封装挂起函数
class SuspendExecutable(private val block: suspend () -> Boolean) : Executable() {
    override fun executeSync(): Boolean = runBlocking { block() }
    override suspend fun executeAsync(): Boolean = block()
}

// 封装普通函数
class NormalExecutable(private val block: () -> Boolean) : Executable() {
    override fun executeSync(): Boolean = block()
    override suspend fun executeAsync(): Boolean = block()
}

步骤2：调整枚举类，持有统一的Executable实例 #

枚举类不再直接暴露具体的函数类型，而是持有Executable接口实例：

enum class Work(val executable: Executable) {
    A(SuspendExecutable { true }),
    B(NormalExecutable { true })
}

步骤3：调用执行逻辑 #

根据业务场景选择同步或异步执行方式，无需关心底层函数类型：

import kotlinx.coroutines.coroutineScope

// 同步执行场景
fun runSync(work: Work) {
    val result = work.executable.executeSync()
    // 处理执行结果
}

// 异步挂起执行场景
suspend fun runAsync(work: Work) {
    val result = work.executable.executeAsync()
    // 处理执行结果
}

// 遍历所有枚举成员执行
fun runAllWorksSync() {
    Work.values().forEach { runSync(it) }
}

suspend fun runAllWorksAsync() {
    coroutineScope {
        Work.values().forEach { runAsync(it) }
    }
}

方案优势 #

1. 无需手动强转：通过抽象接口屏蔽了具体函数类型差异，调用方无需判断类型
2. 保留枚举特性：依然可以用Work.values()遍历所有任务
3. 灵活适配场景：提供同步/异步两种执行入口，适配不同业务需求
4. 扩展性强：后续新增函数类型只需新增Executable子类，无需修改调用逻辑

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