Kotlin的关键字

在Kotlin语言中有一些具有特殊用途的单词被称为关键字(keyword),当定义标识符时,不要让标识符与关键字相同,否则会引起错误。例如,如下代码将会引起错误

val class = 2

Kotlin的关键字可以分为三类

  • 硬关键字:这些关键字无论在什么情况下都不能用作标识符
  • 软关键字:这些关键字可以在他们不起作用的上下文中用作标识符
  • 修饰符关键字:这些关键字也可以在代码中用作标识符

Kotlin的硬关键字包括:

  • as——用于做类型转换或为import语句指定别名。
  • as?——类型安全的类型转换运算符。
  • break——中断循环。
  • class——声明类。
  • continue——忽略本次循环剩下的语句,重新开始下一次循环。
  • do——用于do while循环。
  • true——在Boolean类型中表示真的直接量。
  • false——在Boolean类型中表示假的直接量。
  • else——在if分支中使用。
  • for——用于for循环。
  • fun——声明函数。
  • if——在if分支中使用。
  • in——在for循环中使用;in还可作为双目运算符,检查一个值是否处于区间或集合内; in也可以在when表达式中使用;in还可用于修饰泛型参数,表明该泛型参数支持逆变。
  • !in——可作为双目运算符in的反义词;!in也可在when表达式中使用。
  • is——用于做类型检查(类似Java的instanceof)或在when表达式中使用。
  • !is—用于做类型检查(is的反义词)或在when表达式中使用。
  • null——代表空的直接量。
  • object——用于声明对象表达式或定义命名对象。
  • package——用于为当前文件指定包。
  • return——声明函数的返回。
  • super——用于引用父类实现的方法或属性,或者在子类构造器中调用父类构造器。
  • this——代表当前类的对象或在构造器中调用当前类的其他构造器。
  • throw——用于抛出异常。
  • try——开始异常处理。
  • typealias——用于定义类型别名。
  • val——声明只读属性或变量。
  • var——声明可变属性或变量。
  • when——用于when表达式。
  • while——用于while循环或do while循环。

Koltin的软关键字包括:

  • by——用于将接口或祖先类的实现代理给其他对象。
  • catch——在异常处理中用于捕捉异常。
  • constructor——用于声明构造器。
  • delegate——用于指定该注解修饰委托属性存储其委托实例的字段。
  • dynamic——主要用于在Kotlin/JavaScript中引用一个动态类型。
  • field——用于指定该注解修饰属性的幕后字段
  • file——用于指定该注解修饰该源文件本身
  • finally——异常处理中的finally块。
  • get——用于声明属性的getter方法,或者用于指定该注解修饰属性的getter方法。
  • set——用于声明属性的setter方法,或者用于指定该注解修饰属性的setter 方法。
  • import——用于导包。
  • init——用于声明初始化块。
  • param——用于指定该注解修饰构造器参数。
  • property——用于指定该注解修饰整个属性(这种目标的注解对Java不可见,因为Java并没有真正的属性)。
  • receiveris——用于指定该注解修饰扩展方法或扩展属性的接收者。
  • setparam——用于指定该注解修饰setter方法的参数。
  • where——用于为泛型参数增加限制。

Kotlin的修饰符关键字包括:

  • abstract——用于修饰抽象类或抽象成员。
  • annotation——用于修饰一个注解类。
  • companion——用于声明一个伴生对象。
  • const——用于声明编译时常量。
  • crossinline——用于禁止在传给内联函数的Lambda表达式中执行非局部返回。
  • data——用于声明数据类。
  • enum——用于声明枚举。
  • external——用于声明某个方法不由Kotin实现(与Java的native相似)。
  • final——用于禁止被重写。
  • infix——声明该函数能以双目运算符的格式执行。
  • inline——用于声明内联函数,Lambda表达式可在内联函数中执行局部返回。
  • inner——用于声明内部类,内部类可以访问外部类的实例。
  • internal——用于表示被修饰的声明只能在当前模块内可见。
  • lateinit——用于修饰以个non-null属性,用于指定该属性可在构造器以外的地方完成初始化。
  • noinline——用于禁止内联函数中个别Lambda表达式被内联化。
  • open——用于修饰类,表示该类可派生子类;或者用于修饰成员, 表示该成员可以被重写。
  • out——用于修饰泛型参数,表明该泛型参数支持协变。
  • override——用于声明重写父类的成员。
  • private——private访问权限。
  • protected——proteted 访问权限。
  • public——public访问权限。
  • reified——用于修饰内联函数中的泛型形参,接下来在该函数中就可像使用普通类型样使用该类型参数。
  • sealed——用于声明一个密封类。
  • suspend——用于标识一个函数后Lambda表达式可作为暂停。
  • tailrec——用于修饰一个函数可作为尾随递归函数使用。
  • vararg——用于修饰形参,表明该参数是个数可变的形参。
     
<think>我们正在讨论Kotlin的`sealed`关键字。根据用户要求,我们需要解释其用途和用法,并提供示例。引用[1]提到的是数据类(dataclass),但用户的问题是关于`sealed`关键字的,因此我们需要专注于`sealed`。首先,`sealed`关键字Kotlin中用于声明一个密封类(sealedclass)。密封类用于表示受限制的类层次结构,即一个类可以有有限的一组子类,且这些子类必须在与密封类相同的文件中声明(在Kotlin1.1之后,子类也可以出现在同一个编译单元的其他文件中,但通常还是限定在同一个文件中或通过嵌套的方式)。主要用途:1.限制继承:密封类允许你定义一组固定的子类,这样在`when`表达式中处理所有情况时,可以确保覆盖所有可能的情况(如果覆盖了所有子类,则不需要`else`分支)。2.增强类型安全:由于所有可能的子类都是已知的,编译器可以检查是否处理了所有情况。示例:假设我们有一个表示网络请求结果的密封类,它有两个子类:成功和错误。使用密封类定义: ```kotlinsealed classResult<out T: Any> {dataclass Success<outT :Any>(val data: T) :Result<T>()data classError(valexception:Exception): Result<Nothing>() }```然后,我们可以使用`when`表达式来处理结果: ```kotlinfunhandleResult(result:Result<Data>){when (result){is Result.Success-> {//处理成功情况,可以访问result.dataprintln("Success: ${result.data}")}is Result.Error ->{//处理错误情况println("Error: ${result.exception}")}} }```由于`Result`是密封类,只有两个子类,所以`when`表达式覆盖了所有情况,不需要`else`分支。注意:在Kotlin1.0中,密封类的子类必须嵌套在密封类内部。在Kotlin1.1中,子类可以定义在密封类同一个文件的任何地方。另一个常见用途是表示状态,例如UI状态:```kotlinsealed classViewState {objectLoading :ViewState()data classContent(valitems: List<String>): ViewState()dataclass Error(val message: String) :ViewState() }```然后,在更新UI时: ```kotlinfunupdateUI(state:ViewState) {when(state) {isViewState.Loading-> showLoading()isViewState.Content ->showContent(state.items)is ViewState.Error-> showError(state.message)}} ```同样,由于是密封类,我们处理了所有可能的状态。总结: -密封类用于表示有限的类层次结构。-在`when`表达式中处理密封类的实例时,如果覆盖了所有子类,则不需要`else`分支。-密封类本身是抽象的,不能直接实例化。相关问题:1.密封类和枚举类有什么区别?2.在Kotlin中,密封类与抽象类有何不同?3.如何为密封类添加新的子类?4.密封类在Kotlin中有哪些实际应用场景?</think>### Kotlin `sealed`关键字的用途与用法 `sealed`关键字用于声明**密封类**(sealed class),这是Kotlin中一种特殊的抽象类,主要解决两个核心问题: #### 核心特性 1. **受限继承** 密封类的所有直接子类必须在**同一个文件**中声明(Kotlin 1.1+允许在同一个编译单元的其他文件中声明),形成封闭的类层次结构: ```kotlin sealed class Result<out T> { data class Success<T>(val data: T) : Result<T>() data class Error(val message: String) : Result<Nothing>() } ``` 2. **完备性检查** 配合`when`表达式时,编译器能验证是否覆盖所有子类(无需`else`分支): ```kotlin fun handle(result: Result<String>) = when(result) { is Result.Success -> println(result.data) is Result.Error -> println("Error: ${result.message}") // 无需else,编译器确认覆盖所有情况 } ``` #### 典型应用场景 1. **状态机建模**(如UI状态) ```kotlin sealed class LoginState { object Idle : LoginState() object Loading : LoginState() data class Success(val user: User) : LoginState() data class Failed(val error: Throwable) : LoginState() } ``` 2. **表达式树处理** ```kotlin sealed class Expr { data class Const(val num: Int) : Expr() data class Sum(val left: Expr, val right: Expr) : Expr() } fun eval(expr: Expr): Int = when(expr) { is Expr.Const -> expr.num is Expr.Sum -> eval(expr.left) + eval(expr.right) } ``` 3. **API响应封装** ```kotlin sealed class ApiResponse<out T> { data class Success<T>(val data: T) : ApiResponse<T>() data class Failure(val code: Int) : ApiResponse<Nothing>() } ``` #### 与枚举的区别 | 特性 | 密封类 | 枚举类 | |--------------|---------------------------|---------------------| | 实例差异 | 子类可携带不同数据(如`data class`) | 所有实例类型相同 | | 状态数量 | 子类数量固定但实例数量不限 | 实例数量固定 | | 使用场景 | 需携带异构数据的受限类型 | 纯状态标识 | > 密封类本质是**抽象类**,不能直接实例化,其构造函数默认`protected`[^1]。 #### 版本演进 - **Kotlin 1.0**:子类必须嵌套在密封类内部 - **Kotlin 1.1+**:允许子类在**同一文件**的顶层声明 - **Kotlin 1.5+**:支持密封接口(`sealed interface`) --- ### 相关问题 1. 密封类与枚举类在状态管理中的具体选择标准是什么? 2. 如何在多文件项目中合理组织密封类及其子类? 3. 密封类在函数式编程中有哪些典型应用模式? 4. Kotlin的密封接口(sealed interface)解决了哪些密封类的限制? [^1]: 密封类通过受限继承保证类型安全,常用于替代枚举类扩展带数据的场景。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值