Kotlin 基础

// 可变变量
var name: String = "张三"
var age = 25  // 类型推断

// 不可变变量（推荐）
val pi = 3.14
val message: String = "Hello"

// 延迟初始化
lateinit var user: User

// 数字
val int: Int = 100
val long: Long = 100L
val float: Float = 3.14f
val double: Double = 3.14

// 字符和字符串
val char: Char = 'A'
val str: String = "Hello"

// 布尔
val isTrue: Boolean = true

// 数组
val array = arrayOf(1, 2, 3)
val intArray = intArrayOf(1, 2, 3)

// 字符串模板
val name = "张三"
val message = "你好，$name"
val info = "年龄：${age + 1}"

// 多行字符串
val text = """
    第一行
    第二行
    第三行
""".trimIndent()

// 基本函数
fun add(a: Int, b: Int): Int {
    return a + b
}

// 单表达式函数
fun multiply(a: Int, b: Int) = a * b

// 默认参数
fun greet(name: String = "Guest") {
    println("Hello, $name")
}

// 命名参数
greet(name = "张三")

// 可变参数
fun sum(vararg numbers: Int): Int {
    return numbers.sum()
}

// if 表达式
val max = if (a > b) a else b

// when 表达式
when (x) {
    1 -> println("One")
    2 -> println("Two")
    in 3..10 -> println("3-10")
    else -> println("Other")
}

val result = when {
    x > 0 -> "正数"
    x < 0 -> "负数"
    else -> "零"
}

// for 循环
for (i in 1..5) {
    println(i)
}

for (i in 1 until 5) {  // 1-4
    println(i)
}

for (i in 5 downTo 1) {  // 5-1
    println(i)
}

for (i in 1..10 step 2) {  // 1,3,5,7,9
    println(i)
}

// 遍历数组
val array = arrayOf("a", "b", "c")
for (item in array) {
    println(item)
}

for ((index, item) in array.withIndex()) {
    println("$index: $item")
}

// while 循环
while (condition) {
    // ...
}

// 可空类型
var name: String? = null

// 安全调用
val length = name?.length

// Elvis 操作符
val len = name?.length ?: 0

// 非空断言
val len2 = name!!.length  // 可能抛出异常

// 安全转换
val num: Int? = str as? Int

// 基本类
class Person(val name: String, var age: Int) {
    fun introduce() {
        println("我是 $name，今年 $age 岁")
    }
}

// 使用
val person = Person("张三", 25)
person.introduce()

// 数据类
data class User(val id: Int, val name: String)

val user1 = User(1, "张三")
val user2 = user1.copy(name = "李四")

// 单例
object DatabaseManager {
    fun connect() {
        println("连接数据库")
    }
}

DatabaseManager.connect()

// 基类（必须用 open）
open class Animal(val name: String) {
    open fun makeSound() {
        println("动物叫")
    }
}

// 派生类
class Dog(name: String) : Animal(name) {
    override fun makeSound() {
        println("汪汪汪")
    }
}

// 抽象类
abstract class Shape {
    abstract fun area(): Double
}

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

interface Clickable {
    fun click()
    fun showOff() {
        println("默认实现")
    }
}

class Button : Clickable {
    override fun click() {
        println("按钮被点击")
    }
}

// 为 String 添加扩展
fun String.lastChar(): Char = this[length - 1]

val str = "Hello"
println(str.lastChar())  // o

// 扩展属性
val String.lastIndex: Int
    get() = length - 1

// 基本语法
val sum = { a: Int, b: Int -> a + b }
println(sum(1, 2))

// 集合操作
val numbers = listOf(1, 2, 3, 4, 5)

val doubled = numbers.map { it * 2 }
val evens = numbers.filter { it % 2 == 0 }
val sum = numbers.reduce { acc, n -> acc + n }

// it 参数
numbers.forEach { println(it) }

// List
val list = listOf(1, 2, 3)  // 不可变
val mutableList = mutableListOf(1, 2, 3)  // 可变
mutableList.add(4)

// Set
val set = setOf(1, 2, 3)
val mutableSet = mutableSetOf(1, 2, 3)

// Map
val map = mapOf("a" to 1, "b" to 2)
val mutableMap = mutableMapOf("a" to 1)
mutableMap["c"] = 3

// 操作
val filtered = list.filter { it > 2 }
val mapped = list.map { it * 2 }
val sorted = list.sortedDescending()

// 启动协程
GlobalScope.launch {
    delay(1000)
    println("World")
}
println("Hello")

// 挂起函数
suspend fun fetchData(): String {
    delay(1000)
    return "Data"
}

// 使用
lifecycleScope.launch {
    val data = fetchData()
    println(data)
}

// async/await
val deferred = async {
    fetchData()
}
val result = deferred.await()

// let
val result = str?.let {
    it.toUpperCase()
}

// apply（配置对象）
val person = Person().apply {
    name = "张三"
    age = 25
}

// also（附加操作）
val numbers = mutableListOf(1, 2, 3).also {
    println("添加前：$it")
}.apply {
    add(4)
}

// run
val result = person.run {
    introduce()
    age
}

// with
with(person) {
    introduce()
}

sealed class Result {
    data class Success(val data: String) : Result()
    data class Error(val message: String) : Result()
    object Loading : Result()
}

fun handleResult(result: Result) {
    when (result) {
        is Result.Success -> println(result.data)
        is Result.Error -> println(result.message)
        Result.Loading -> println("加载中")
    }
}

// 属性委托
class User {
    var name: String by Delegates.observable("初始值") { prop, old, new ->
        println("$old -> $new")
    }
}

// lazy 委托
val data: String by lazy {
    println("初始化")
    "数据"
}

// 类委托
interface Base {
    fun print()
}

class BaseImpl : Base {
    override fun print() = println("Base")
}

class Derived(b: Base) : Base by b

val base = BaseImpl()
val derived = Derived(base)
derived.print()  // 委托给 base