Kotlin 变量与常量 #

val name: String = "Kotlin"
val age = 25  // 类型推断

// 错误：不能重新赋值
// name = "Java"

var count: Int = 0
count = 10  // 正确：可以重新赋值

var message = "Hello"
message = "World"  // 正确

// val 引用不可变，但对象内容可变
val list = mutableListOf(1, 2, 3)
list.add(4)  // 正确：修改列表内容
// list = mutableListOf()  // 错误：不能重新赋值

val name = "Kotlin"      // 推断为 String
val age = 25             // 推断为 Int
val price = 99.99        // 推断为 Double
val isActive = true      // 推断为 Boolean

// 显式指定类型
val count: Long = 100
val score: Float = 95.5f

// 错误：无法推断类型
// val name

// 正确：显式指定类型
val name: String
name = "Kotlin"

val APP_NAME = "MyApp"
var globalCounter = 0

fun main() {
    println(APP_NAME)
    globalCounter++
}

class Person {
    val name: String = "Unknown"  // 只读属性
    var age: Int = 0              // 可变属性
}

fun calculate() {
    val a = 10
    var b = 20
    b = a + b
    return b
}

class MainActivity {
    // 延迟初始化，不需要立即赋值
    lateinit var name: String
    
    fun init() {
        name = "Kotlin"  // 在使用前初始化
    }
    
    fun printName() {
        // 检查是否已初始化
        if (::name.isInitialized) {
            println(name)
        }
    }
}

// 错误用法
// lateinit val name: String     // 错误：必须是 var
// lateinit var age: Int         // 错误：不能是基本类型
// lateinit var name: String?    // 错误：不能是可空类型

val heavyObject: HeavyClass by lazy {
    println("初始化...")
    HeavyClass()  // 第一次访问时才初始化
}

// 使用
println("开始")
println(heavyObject)  // 此时才初始化
println(heavyObject)  // 使用缓存值

// 指定线程模式
val data by lazy(LazyThreadSafetyMode.NONE) {
    loadData()
}

const val MAX_COUNT = 100
const val APP_NAME = "MyApp"
const val PI = 3.14159

// 错误：const 只能用于顶层或 object 中
// class MyClass {
//     const val VALUE = 10  // 错误
// }

// 普通常量（运行时常量）
val currentTime = System.currentTimeMillis()

// 编译时常量
const val VERSION = "1.0.0"

const val MAX_SIZE = 100
const val DEFAULT_TIMEOUT = 30000L
const val API_BASE_URL = "https://api.example.com"

val isEmpty: Boolean
    get() = this.size == 0

class Circle(val radius: Double) {
    val area: Double
        get() = Math.PI * radius * radius
}

val circle = Circle(5.0)
println(circle.area)  // 每次访问都计算

class Person {
    var name: String = ""
        set(value) {
            field = value.trim()
        }
    
    var age: Int = 0
        set(value) {
            field = if (value >= 0) value else 0
        }
}

val person = Person()
person.name = "  Kotlin  "
println(person.name)  // "Kotlin"（已去除空格）

class Counter {
    var count = 0
        get() = field
        set(value) {
            if (value >= 0) {
                field = value
            }
        }
}

typealias UserMap = Map<String, User>
typealias Predicate<T> = (T) -> Boolean
typealias ClickHandler = (View) -> Unit

// 使用
val users: UserMap = mapOf()
val isAdult: Predicate<Person> = { it.age >= 18 }

val globalVar = 100

fun outer() {
    val outerVar = 200
    
    fun inner() {
        val innerVar = 300
        println(globalVar)   // 可访问
        println(outerVar)    // 可访问
        println(innerVar)    // 可访问
    }
}

val count = 10

fun test() {
    val count = 20  // 遮蔽外部变量
    println(count)  // 输出 20
    
    if (true) {
        val count = 30  // 遮蔽函数级变量
        println(count)  // 输出 30
    }
    
    println(count)  // 输出 20
}

// 推荐
val name = "Kotlin"
val items = listOf(1, 2, 3)

// 只在需要时使用 var
var counter = 0
counter++

// 不推荐
val n = "Kotlin"
val a = 25

// 推荐
val name = "Kotlin"
val age = 25

// val 延迟初始化 → 使用 lazy
val database: Database by lazy { Database.connect() }

// var 延迟初始化 → 使用 lateinit
lateinit var service: ApiService

// 不推荐
var globalCounter = 0

// 推荐：使用封装
object Counter {
    private var _count = 0
    val count: Int get() = _count
    
    fun increment() = _count++
}