编辑“︁Kotlin关键字”︁

= Kotlin关键字 =

== 介绍 ==
'''Kotlin关键字'''是Kotlin编程语言中具有特殊含义的保留标识符，用于定义语法结构、控制流程或声明特定行为。这些关键字不能用作变量名、函数名或其他自定义标识符。Kotlin的关键字分为两类：
* '''硬关键字（Hard Keywords）'''：始终不能作为标识符
* '''软关键字（Soft Keywords）'''：在特定上下文外可作为标识符使用

== 关键字分类 ==

=== 硬关键字 ===
以下关键字在任何情况下都不能用作标识符：

<syntaxhighlight lang="kotlin">
// 声明相关
class, fun, val, var, const, typealias

// 控制流
if, else, when, for, while, do, break, continue, return

// 异常处理
try, catch, finally, throw

// 面向对象
interface, object, companion, this, super

// 类型系统
is, in, !in, as, as?

// 其他
package, import, where, by, get, set, field, dynamic, typeof
</syntaxhighlight>

=== 软关键字 ===
这些关键字在特定上下文外可用作标识符：

<syntaxhighlight lang="kotlin">
// 仅在特定位置作为关键字
file, init, param, setparam, property, receiver

// 注解相关
annotation, crossinline, data, enum, inner, internal, 
lateinit, noinline, open, operator, out, override, 
private, protected, public, reified, sealed, suspend, 
tailrec, vararg, inline, value, expect, actual
</syntaxhighlight>

== 重要关键字详解 ==

=== val 与 var ===
'''val'''声明只读变量（不可变引用），'''var'''声明可变变量：

<syntaxhighlight lang="kotlin">
fun main() {
    val pi = 3.14 // 不可变
    var counter = 0 // 可变
    
    // pi = 3.1415 // 编译错误：Val cannot be reassigned
    counter++ // 允许修改
    
    println("PI: $pi, Counter: $counter")
}
</syntaxhighlight>

输出：
<pre>
PI: 3.14, Counter: 1
</pre>

=== when 表达式 ===
Kotlin的'''when'''取代了传统switch语句，功能更强大：

<syntaxhighlight lang="kotlin">
fun describe(obj: Any): String = when (obj) {
    1          -> "One"
    "Hello"    -> "Greeting"
    is Long    -> "Long number"
    !is String -> "Not a string"
    else       -> "Unknown"
}

fun main() {
    println(describe(1))          // 输出: One
    println(describe("Hello"))     // 输出: Greeting
    println(describe(1000L))       // 输出: Long number
    println(describe(2.0))         // 输出: Not a string
    println(describe("other"))     // 输出: Unknown
}
</syntaxhighlight>

=== data class ===
'''data'''关键字自动生成常用方法（toString(), equals(), hashCode(), copy()等）：

<syntaxhighlight lang="kotlin">
data class User(val name: String, val age: Int)

fun main() {
    val user1 = User("Alice", 25)
    val user2 = user1.copy(age = 26)
    
    println(user1)        // 输出: User(name=Alice, age=25)
    println(user1 == user2) // 输出: false
    println(user1.hashCode())
}
</syntaxhighlight>

== 修饰符关键字 ==

=== 可见性修饰符 ===
Kotlin提供四种可见性修饰符：

<mermaid>
classDiagram
    class Visibility {
        +public (默认)
        #protected
        ~internal
        -private
    }
</mermaid>

示例：
<syntaxhighlight lang="kotlin">
open class Parent {
    private val a = 1
    protected open val b = 2
    internal val c = 3
    val d = 4 // 默认public
}

class Child : Parent() {
    // a不可见
    override val b = 5 // 可访问父类的protected成员
    // c和d保持可见
}
</syntaxhighlight>

== 高级关键字 ==

=== reified 与内联函数 ===
'''reified'''允许在运行时访问泛型类型信息：

<syntaxhighlight lang="kotlin">
inline fun <reified T> checkType(value: Any) {
    if (value is T) {
        println("Value is of type ${T::class.simpleName}")
    } else {
        println("Value is NOT of type ${T::class.simpleName}")
    }
}

fun main() {
    checkType<String>("Hello")  // 输出: Value is of type String
    checkType<Int>("World")     // 输出: Value is NOT of type Int
}
</syntaxhighlight>

=== sealed 类 ===
'''sealed'''类限制继承层级，常用于表示受限的类继承结构：

<syntaxhighlight lang="kotlin">
sealed class Result<out T> {
    data class Success<out T>(val data: T) : Result<T>()
    data class Error(val exception: Exception) : Result<Nothing>()
    object Loading : Result<Nothing>()
}

fun handleResult(result: Result<String>) = when(result) {
    is Result.Success -> println("Data: ${result.data}")
    is Result.Error -> println("Error: ${result.exception}")
    Result.Loading -> println("Loading...")
    // 不需要else分支，因为所有情况已覆盖
}
</syntaxhighlight>

== 实际应用案例 ==

=== 使用 by 关键字实现委托 ===
Kotlin通过'''by'''关键字支持委托模式：

<syntaxhighlight lang="kotlin">
interface Database {
    fun save(data: String)
}

class RealDatabase : Database {
    override fun save(data: String) {
        println("Saving '$data' to real database")
    }
}

class DatabaseProxy(db: Database) : Database by db {
    override fun save(data: String) {
        println("Logging save operation")
        if (data.isNotBlank()) {
            // 委托给RealDatabase
            (this as Database).save(data)
        }
    }
}

fun main() {
    val db = DatabaseProxy(RealDatabase())
    db.save("Kotlin is awesome!")
}
</syntaxhighlight>

输出：
<pre>
Logging save operation
Saving 'Kotlin is awesome!' to real database
</pre>

== 数学公式示例 ==
当讨论类型安全时，可以用公式表示类型转换的安全性：

<math>
P(T_{safe}) = \begin{cases} 
1, & \text{当转换保证安全时} \\
0, & \text{当转换可能失败时}
\end{cases}
</math>

其中<math>T_{safe}</math>表示安全类型转换操作。

== 总结 ==
Kotlin的关键字系统设计既简洁又强大，通过合理使用这些关键字可以：
* 编写更安全的代码（val, null安全相关关键字）
* 创建更清晰的语法结构（when, data class）
* 实现高级编程范式（reified, sealed）
* 管理可见性和作用域（public, internal等）

理解这些关键字是掌握Kotlin语言的基础，建议通过实际编码练习来熟悉它们的用法。

[[Category:编程语言]]
[[Category:Kotlin]]
[[Category:Kotlin基础]]