Kotlin关键字

Kotlin关键字可分为 3类。

  • 硬关键字: 这些关键字无论在什么情况下都不能用作标识符。

  • 软关键字: 这些关键字可以在它们不起作用的上下文中用作标识符。

  • 修饰符关键字: 这些关键字也可以在代码中用作标识符。


Kotlin的硬关键宇包括:


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

Kotlin 的软关键宇包括:


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

 

Kotlin 的修饰符关键宇包括:


abstract一一用于修饰抽象类或抽象成员
annotation 一一用于修饰一个注解类。
companion 一一用于声明一个伴生对象
const一一用于声明编译时常量
crossinline一一用于禁止在传给内联函数的 Lambd 表达式中执行非局部返回
data一一用于声明数据类。
enum一一用于声明枚举
external一一用于声明某个方法不由 Kotlin 实现(与 Java 的 native 相似〉。
final 一一用于禁止被重写
infix一一声明该函数能以双目运算符的格式执行
inline 一一用于声明内联函数, Lambda 表达式可在内联函数中执行局部返回。
inner一一用于声明内部类,内部类可以访问外部类的实例
internal 一一用于表示被修饰的声明只能在当前模块内可见
lateinit-------用于修饰 non-null 属性,用于指定该属性可在构造器以外的地方
初始化
noinline一一用于禁止内联函数中个别 Lambda 表达式被内联化
open 一一用于修饰类,表示该类可派生子类;或者用于修饰成员,表示该成员可以被
重写。
out一一用于修饰泛型参数,表明该泛型参数支持协变。
override一一用于声明重写父类的成员
private ------private 访问权限
protected --------protected 访问权限
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、付费专栏及课程。

余额充值