Kotlin基础语法 #

// val - 不可变变量（只读，相当于final）
val name = "Kotlin"
val age: Int = 10

// var - 可变变量
var count = 0
count = 1

// 类型推断
val message = "Hello"  // 自动推断为String
val number = 42        // 自动推断为Int

// 显式类型声明
val price: Double = 19.99
val isActive: Boolean = true

// 字符串模板
val name = "World"
val greeting = "Hello, $name!"
val expression = "2 + 2 = ${2 + 2}"

// 多行字符串
val text = """
    这是
    多行
    字符串
""".trimIndent()

// 原始字符串
val json = """
    {
        "name": "Kotlin",
        "version": 1.9
    }
""".trimIndent()

// 可空类型
var name: String? = "Kotlin"
name = null  // 允许为null

// 非空类型
var nonNullName: String = "Kotlin"
// nonNullName = null  // 编译错误

// 安全调用操作符 ?.
val length = name?.length  // 如果name为null，返回null

// Elvis操作符 ?:
val len = name?.length ?: 0  // 如果name为null，返回0

// 非空断言 !!（谨慎使用）
val forceLength = name!!.length  // 如果name为null，抛出NPE

// 安全转换
val number: Int? = "123" as? Int

val a = 10
val b = 3

val sum = a + b       // 加法: 13
val diff = a - b      // 减法: 7
val product = a * b   // 乘法: 30
val quotient = a / b  // 除法: 3
val remainder = a % b // 取余: 1

// 范围
val range = 1..10     // 1到10
val until = 1 until 10  // 1到9
val downTo = 10 downTo 1  // 10到1

val x = 5
val y = 10

x == y   // 等于
x != y   // 不等于
x < y    // 小于
x > y    // 大于
x <= y   // 小于等于
x >= y   // 大于等于

// 区间检查
x in 1..10  // x是否在1到10之间
x !in 1..10 // x是否不在1到10之间

val a = true
val b = false

val and = a && b  // 与
val or = a || b   // 或
val not = !a      // 非

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

// if-else if-else
val score = 85
val grade = if (score >= 90) {
    "A"
} else if (score >= 80) {
    "B"
} else if (score >= 70) {
    "C"
} else {
    "D"
}

// when表达式（类似switch）
val day = 1
val dayName = when (day) {
    1 -> "星期一"
    2 -> "星期二"
    3 -> "星期三"
    4 -> "星期四"
    5 -> "星期五"
    6, 7 -> "周末"
    in 8..100 -> "无效"
    else -> "未知"
}

// when类型检查
val obj: Any = "Hello"
when (obj) {
    is Int -> println("整数: $obj")
    is String -> println("字符串: $obj")
    is Double -> println("双精度: $obj")
    else -> println("未知类型")
}

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

for (i in 1 until 5) {
    println(i)
}

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

for (i in 1..10 step 2) {
    println(i)
}

// 遍历集合
val list = listOf("A", "B", "C")
for (item in list) {
    println(item)
}

// 带索引遍历
for ((index, value) in list.withIndex()) {
    println("$index: $value")
}

// while循环
var i = 0
while (i < 5) {
    println(i)
    i++
}

// do-while循环
var j = 0
do {
    println(j)
    j++
} while (j < 5)

// 循环控制
for (i in 1..10) {
    if (i == 3) continue  // 跳过本次循环
    if (i == 7) break     // 跳出循环
    println(i)
}

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

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

// 无返回值
fun greet(name: String): Unit {
    println("Hello, $name!")
}

// 省略Unit
fun greet(name: String) {
    println("Hello, $name!")
}

fun greet(name: String, greeting: String = "Hello") {
    println("$greeting, $name!")
}

greet("Kotlin")              // Hello, Kotlin!
greet("Kotlin", "Hi")        // Hi, Kotlin!
greet(greeting = "Hi", name = "Kotlin")  // 命名参数

fun sum(vararg numbers: Int): Int {
    return numbers.sum()
}

sum(1, 2, 3)           // 6
sum(1, 2, 3, 4, 5)     // 15

// 展开数组
val nums = intArrayOf(1, 2, 3)
sum(*nums)             // 6

// 为String添加扩展函数
fun String.isEmail(): Boolean {
    return this.contains("@")
}

val email = "test@example.com"
email.isEmail()  // true

// 扩展属性
val String.firstChar: Char
    get() = this[0]

"Kotlin".firstChar  // 'K'

// 函数类型
val add: (Int, Int) -> Int = { a, b -> a + b }

// 高阶函数
fun calculate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

calculate(5, 3) { x, y -> x + y }  // 8
calculate(5, 3) { x, y -> x * y }  // 15

// 常用高阶函数
val numbers = listOf(1, 2, 3, 4, 5)

// map - 映射
numbers.map { it * 2 }  // [2, 4, 6, 8, 10]

// filter - 过滤
numbers.filter { it > 2 }  // [3, 4, 5]

// find - 查找
numbers.find { it > 3 }  // 4

// any - 是否存在
numbers.any { it > 5 }  // false

// all - 是否全部满足
numbers.all { it > 0 }  // true

// reduce - 累积
numbers.reduce { acc, n -> acc + n }  // 15

// forEach - 遍历
numbers.forEach { println(it) }

// Lambda语法
val sum = { a: Int, b: Int -> a + b }

// 简化写法
val list = listOf(1, 2, 3, 4, 5)
list.filter { it > 2 }  // it是隐式参数

// 多行Lambda
list.map { 
    val doubled = it * 2
    doubled.toString()
}

class Person {
    // 属性
    var name: String = ""
    var age: Int = 0
    
    // 方法
    fun introduce() {
        println("我是$name，今年$age岁")
    }
}

// 使用
val person = Person()
person.name = "Kotlin"
person.age = 10
person.introduce()

// 主构造函数
class Person(val name: String, var age: Int) {
    fun introduce() {
        println("我是$name，今年$age岁")
    }
}

// 初始化块
class Person(val name: String) {
    var age: Int = 0
    
    init {
        println("创建Person: $name")
    }
}

// 次构造函数
class Person(val name: String) {
    var age: Int = 0
    
    constructor(name: String, age: Int) : this(name) {
        this.age = age
    }
}

data class User(val id: Int, val name: String, val email: String)

// 自动生成equals、hashCode、toString、copy
val user1 = User(1, "Kotlin", "kotlin@example.com")
val user2 = user1.copy(name = "Java")

println(user1)  // User(id=1, name=Kotlin, email=kotlin@example.com)
println(user1 == user2)  // false

// 解构声明
val (id, name, email) = user1

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("加载中...")
    }
}

enum class Direction {
    NORTH, SOUTH, EAST, WEST
}

enum class Color(val rgb: Int) {
    RED(0xFF0000),
    GREEN(0x00FF00),
    BLUE(0x0000FF)
}

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

Database.connect()

// 伴生对象（类似静态成员）
class Utils {
    companion object {
        const val VERSION = "1.0"
        
        fun log(message: String) {
            println(message)
        }
    }
}

Utils.log("Hello")
println(Utils.VERSION)

interface Clickable {
    fun click()
    
    fun show() {
        println("显示")
    }
}

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

// 父类需要使用open关键字
open class Animal(val name: String) {
    open fun sound() {
        println("$name 发出声音")
    }
}

class Dog(name: String) : Animal(name) {
    override fun sound() {
        println("$name 汪汪叫")
    }
}

abstract class Shape {
    abstract fun area(): Double
    
    fun info() {
        println("这是一个形状")
    }
}

class Rectangle(val width: Double, val height: Double) : Shape() {
    override fun area(): Double {
        return width * height
    }
}

// 不可变List
val list = listOf(1, 2, 3)
val mixedList = listOf(1, "two", 3.0)

// 可变List
val mutableList = mutableListOf(1, 2, 3)
mutableList.add(4)
mutableList.removeAt(0)

// 访问
list[0]          // 1
list.getOrNull(5)  // null
list.first()     // 1
list.last()      // 3

// 不可变Set
val set = setOf(1, 2, 3, 2, 1)  // {1, 2, 3}

// 可变Set
val mutableSet = mutableSetOf(1, 2, 3)
mutableSet.add(4)
mutableSet.remove(1)

// 不可变Map
val map = mapOf("a" to 1, "b" to 2)

// 可变Map
val mutableMap = mutableMapOf("a" to 1, "b" to 2)
mutableMap["c"] = 3
mutableMap.remove("a")

// 访问
map["a"]         // 1
map.getValue("a")  // 1
map.getOrDefault("c", 0)  // 0

import kotlinx.coroutines.*

// 在Activity中使用
class MainActivity : AppCompatActivity() {
    private val scope = MainScope()
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        scope.launch {
            val result = withContext(Dispatchers.IO) {
                // 执行耗时操作
                fetchData()
            }
            // 更新UI
            textView.text = result
        }
    }
    
    override fun onDestroy() {
        super.onDestroy()
        scope.cancel()
    }
}

// launch - 启动新协程，不返回结果
scope.launch {
    delay(1000)
    println("Hello")
}

// async - 启动新协程，返回Deferred
val deferred = scope.async {
    delay(1000)
    "Result"
}
val result = deferred.await()

// withContext - 切换上下文
withContext(Dispatchers.IO) {
    // 在IO线程执行
}