编辑“︁Kotlin变量”︁（章节）

= Kotlin变量 =

在Kotlin中，'''变量'''是存储数据的基本单元，通过声明变量可以赋予程序动态处理数据的能力。与Java等语言不同，Kotlin的变量设计强调'''不可变性优先'''原则，通过`val`和`var`关键字提供显式的可变性控制。

== 变量声明基础 ==
Kotlin使用以下两种关键字声明变量：

=== 1. 只读变量（val） ===
* 使用`val`（value的缩写）声明'''不可重新赋值'''的变量（类似Java的`final`变量）：
<syntaxhighlight lang="kotlin">
fun main() {
    val pi = 3.14159
    println("圆周率: $pi")
    // pi = 3.14  // 编译错误：Val cannot be reassigned
}
</syntaxhighlight>
{{Output|
圆周率: 3.14159
}}

=== 2. 可变变量（var） ===
* 使用`var`（variable的缩写）声明'''可修改'''的变量：
<syntaxhighlight lang="kotlin">
fun main() {
    var counter = 0
    println("初始值: $counter")
    counter += 1
    println("修改后: $counter")
}
</syntaxhighlight>
{{Output|
初始值: 0
修改后: 1
}}

== 类型系统 ==
Kotlin是'''静态类型语言'''，但支持类型推断：

=== 显式类型声明 ===
<syntaxhighlight lang="kotlin">
val message: String = "Hello"
var count: Int = 10
</syntaxhighlight>

=== 类型推断 ===
编译器可自动推断类型（推荐方式）：
<syntaxhighlight lang="kotlin">
val name = "Kotlin"  // 推断为String
var score = 95.5     // 推断为Double
</syntaxhighlight>

== 变量作用域 ==
Kotlin变量的作用域遵循'''词法作用域'''规则：

<mermaid>
flowchart TD
    A[全局变量] -->|文件顶层声明| B(整个文件可见)
    C[局部变量] -->|函数/代码块内声明| D(仅块内可见)
</mermaid>

示例：
<syntaxhighlight lang="kotlin">
val global = "全局"  // 顶层变量

fun printData() {
    val local = "局部"
    println("$global - $local")  // 正常访问
    // println(anotherLocal)    // 编译错误
    if (true) {
        val anotherLocal = "块内"
        println(anotherLocal)    // 正常访问
    }
}
</syntaxhighlight>

== 高级特性 ==
=== 延迟初始化 ===
使用`lateinit`避免非空类型的立即初始化（仅适用于`var`）：
<syntaxhighlight lang="kotlin">
lateinit var config: String

fun setup() {
    config = "加载配置"
    println(config.length)  // 正常访问
}
</syntaxhighlight>
{{Warning|访问未初始化的`lateinit`变量会抛出`UninitializedPropertyAccessException`}}

=== 惰性初始化 ===
使用`by lazy`实现按需初始化（仅适用于`val`）：
<syntaxhighlight lang="kotlin">
val heavyData: String by lazy {
    println("执行初始化计算")
    "大数据计算结果"
}

fun main() {
    println(heavyData)  // 首次访问时初始化
    println(heavyData)  // 直接返回缓存值
}
</syntaxhighlight>
{{Output|
执行初始化计算
大数据计算结果
大数据计算结果
}}

== 实际应用案例 ==
=== 场景1：用户会话管理 ===
<syntaxhighlight lang="kotlin">
class UserSession {
    var authToken: String? = null  // 可空可变变量
    val userId: String by lazy { generateUserId() }

    private fun generateUserId(): String {
        return "user-${System.currentTimeMillis()}"
    }
}
</syntaxhighlight>

=== 场景2：配置参数处理 ===
<syntaxhighlight lang="kotlin">
object AppConfig {
    const val API_VERSION = "v1.0"  // 编译时常量
    var debugMode = false           // 运行时可变参数

    fun toggleDebug() {
        debugMode = !debugMode
        println("Debug模式: ${if (debugMode) "开启" else "关闭"}")
    }
}
</syntaxhighlight>

== 最佳实践 ==
* 优先使用`val`声明变量，仅在需要修改时使用`var`
* 对基本数据类型使用`const val`声明编译时常量
* 复杂对象的延迟初始化优先选择`by lazy`而非`lateinit`
* 避免使用全局可变变量（`var`），推荐通过类封装

== 常见问题 ==
{{Q&A
|question = 何时使用类型声明而非类型推断？
|answer = 当变量初始化表达式复杂或需要明确文档化类型时建议显式声明，例如：<br><code>val data: Map<String, List<Int>> = parseComplexData()</code>
}}
{{Q&A
|question = `val`变量真的完全不可变吗？
|answer = 对于引用类型，`val`仅保证引用不变，对象内容仍可能改变。例如：<br><syntaxhighlight lang="kotlin">
val list = mutableListOf(1, 2, 3)
list.add(4)  // 合法操作
// list = mutableListOf()  // 非法操作
</syntaxhighlight>
}}

== 数学表示 ==
变量可视为从内存地址到值的映射：
<math>
variable: Address \rightarrow Value
</math>
其中Kotlin通过类型系统保证：
<math>
\forall v \in Variables, type(v) \subseteq TypeSystem
</math>

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