Kotlin中sealed与internal的区别及适用场景咨询

核心差异 #

1. 作用领域完全不同 #

• sealed（密封类）：管的是类的继承规则，强制所有子类必须定义在可控范围内（同一文件或同模块子包），核心是让编译器能识别所有可能的子类，做穷尽性检查。
• internal（可见性修饰符）：管的是访问权限，限定只有同一编译模块内的代码能访问目标类/成员，和继承逻辑完全无关。

2. 使用目的天差地别 #

• sealed：用来实现有限的类型层次，比如状态、事件、错误类型这类“所有可能情况都能列全”的场景，避免出现未被处理的子类。
• internal：用来隐藏模块内部的实现细节，对外只暴露必要的公共API，减少模块间的耦合度。

3. 生效范围不一样 #

• sealed：子类只能在同一文件（Kotlin 1.0）或同模块的子包/同一文件（Kotlin 1.1+）里定义，跨模块根本没法创建它的子类。
• internal：只要是同一编译模块内的代码，不管在哪个文件、哪个包，都能访问；跨模块则完全看不到这个类/成员。

实际代码示例 #

示例1：sealed类的典型用法（状态管理） #

比如定义网络请求的所有可能状态，确保when表达式不会遗漏情况：

// 密封类：所有子类必须在可控范围内定义
sealed class NetworkState {
    object Loading : NetworkState()
    data class Success(val data: String) : NetworkState()
    data class Error(val message: String) : NetworkState()
}

fun handleRequestState(state: NetworkState) {
    // 编译器会自动检查是否覆盖了所有sealed子类，遗漏直接报错
    when (state) {
        is NetworkState.Loading -> println("加载中，请稍候...")
        is NetworkState.Success -> println("请求成功，数据：${state.data}")
        is NetworkState.Error -> println("请求失败，原因：${state.message}")
        // 不需要写else分支，因为编译器知道所有可能的情况
    }
}

要是后续新增一个Empty状态子类，编译器会立刻提示你在when表达式里处理它，彻底避免遗漏。

示例2：internal的典型用法（隐藏内部实现） #

假设我们做一个用户管理模块，对外只暴露UserManager，内部的存储逻辑藏起来：

// 对外公开的公共API，其他模块可以直接用
class UserManager {
    private val storage = UserStorage()

    fun saveUserName(name: String) {
        storage.storeUser(name)
    }
}

// 内部实现类，只有同一模块内的代码能访问，外部看不到
internal class UserStorage {
    fun storeUser(data: String) {
        println("已存储用户数据：$data")
    }
}

这里UserStorage被标记为internal，其他模块根本没法直接引用，只能通过UserManager来使用存储功能，完美封装了内部细节。

示例3：两者结合使用（模块内类型安全+封装） #

有时候会把sealed和internal结合，比如模块内部的状态，既限制子类范围，又不让外部模块看到：

// 模块内部的密封状态，外部模块完全不可见
internal sealed class ModuleInternalState {
    object Initializing : ModuleInternalState()
    object Ready : ModuleInternalState()
    object Failed : ModuleInternalState()
}

// 模块内的控制器使用这个密封状态
internal class ModuleController {
    fun checkModuleStatus(state: ModuleInternalState) {
        when (state) {
            ModuleInternalState.Initializing -> println("模块正在初始化")
            ModuleInternalState.Ready -> println("模块已准备就绪")
            ModuleInternalState.Failed -> println("模块初始化失败")
        }
    }
}

这样既保证了模块内部的类型安全（所有状态都能被穷尽处理），又把这些细节完全隐藏在模块内部，对外不会暴露多余的API。

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