Kotlin

val notNull: Int = 100      // 不能为 null
val nullable: Int? = null   // 可以为 null

val name = "张三"
val age = 25
// 简单变量
val msg1 = "姓名：$name"
// 表达式
val msg2 = "明年 ${age + 1} 岁"
// 调用方法
val msg3 = "大写：${name.uppercase()}"

val tableName = "users"
val sql = """
    SELECT * 
    FROM $tableName
    WHERE age > 20
    ORDER BY name
""".trimIndent()

val price = 100
// 如果不加 {}，Kotlin 会认为变量名是 price元
val msg1 = "${price}元"  // 正确
// val msg2 = "$price元"  // 错误

// 表达式必须用 {}
val msg3 = "总价：${price * 3}"

// when 作为表达式，有返回值
val score = 85
val grade = when (score) {
    in 90..100 -> "优秀"
    in 80..89 -> "良好"
    in 60..79 -> "及格"
    else -> "不及格"
}

// 多个条件用逗号分隔
val dayOfWeek = 1
val dayType = when (dayOfWeek) {
    1, 2, 3, 4, 5 -> "工作日"
    6, 7 -> "周末"
    else -> "无效"
}

// 类型判断
fun describe(obj: Any) = when (obj) {
    is String -> "字符串，长度 ${obj.length}"
    is Int -> "整数"
    is List<*> -> "列表，大小 ${obj.size}"
    else -> "其他类型"
}

// 无参数的 when，替代 if-else
val x = 10
when {
    x > 0 -> println("正数")
    x < 0 -> println("负数")
    else -> println("零")
}

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

fun handle(result: Result) = when (result) {
    is Result.Success -> println(result.data)
    is Result.Error -> println(result.message)
    Result.Loading -> println("加载中")
    // 不需要 else，因为已经覆盖了所有情况
}

// public：默认，任何地方可见
class PublicClass

// private：只在当前文件或类内可见
private class PrivateClass

// internal：同一模块内可见
internal class InternalClass

// protected：只能用在类成员上，子类可见
open class Parent {
    protected fun protectedMethod() {}
}

// 只在当前文件内可见
private fun helperFunction() {}

// 同一模块内可见
internal fun moduleFunction() {}

// 非空类型，不能为 null
var name: String = "张三"
// name = null  // 编译错误

// 可空类型，可以为 null
var nullableName: String? = "李四"
nullableName = null  // OK

// 访问可空类型时，必须处理 null 的情况
// nullableName.length  // 编译错误
nullableName?.length  // 安全调用，如果为 null 返回 null

val name: String? = null

// 安全调用
val length = name?.length  // 返回 null

// Elvis 操作符提供默认值
val length2 = name?.length ?: 0  // 返回 0

// 非空断言，慎用
// val length3 = name!!.length  // 会抛异常

val obj: Any = "Hello"
val str: String? = obj as? String  // 成功，str = "Hello"
val num: Int? = obj as? Int        // 失败，num = null

val name: String? = "张三"
name?.let {
    // 这里 it 是非空的 String
    println("姓名：$it")
    println("长度：${it.length}")
}

val nonNull: String = "Hello"
val nullable: String? = nonNull  // OK

val nullable2: String? = null
// val nonNull2: String = nullable2  // 编译错误
val nonNull3: String = nullable2 ?: "默认值"  // OK，提供默认值

val list1: List<String> = listOf("a", "b")  // 列表和元素都非空
val list2: List<String?> = listOf("a", null)  // 列表非空，元素可空
val list3: List<String>? = null  // 列表可空，元素非空
val list4: List<String?>? = null  // 都可空

// 这种情况可以用 !!
val intent = Intent()
intent.putExtra("key", "value")
val value = intent.getStringExtra("key")!!  // 刚刚放进去，肯定不为 null

// 但更好的做法是提供默认值
val value2 = intent.getStringExtra("key") ?: "defaultValue"

// Java 中需要层层判空
String city = null;
if (user != null) {
    if (user.getAddress() != null) {
        city = user.getAddress().getCity();
    }
}

// Kotlin 一行搞定
val city = user?.address?.city

val name: String? = getName()

// 使用 ?.
name?.let {
    println("姓名：$it")
    println("长度：${it.length}")
    // 可以执行多个操作
}

// 相当于
if (name != null) {
    println("姓名：$name")
    println("长度：${name.length}")
}

▼kotlin

复制代码fun processUser(user: User?) {
    val validUser = user ?: return  // 如果为 null，直接返回
    // 这里 validUser 是非空的
    println(validUser.name)
}

fun login(username: String?) {
    val name = username ?: throw IllegalArgumentException("用户名不能为空")
    // 这里 name 是非空的
    performLogin(name)
}

// 获取用户城市，如果任何环节为 null，返回"未知"
val city = user?.address?.city ?: "未知"

// 获取列表第一个元素，如果列表为空或为 null，返回默认值
val first = list?.firstOrNull() ?: "默认值"

// 计算字符串长度，null 时返回 0
val length = text?.length ?: 0

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

// Elvis 操作符处理 null
val value = nullableValue ?: defaultValue

// 如果用 if 写，就啰嗦了
val value2 = if (nullableValue != null) nullableValue else defaultValue

// 从 Intent 获取参数
val userId = intent.getStringExtra("userId") ?: "default_id"

// 从配置读取值
val timeout = config.timeout ?: 30000

// API 返回值处理
val data = response.body()?.data ?: emptyList()

// Java 代码
public class JavaClass {
    public String getName() {
        return null;  // 可能返回 null
    }
}

// Kotlin 调用
val javaObj = JavaClass()
val name = javaObj.name  // name 的类型是 String!（平台类型）

// 如果直接使用，可能出问题
// val length = name.length  // 如果 name 为 null，抛异常

// 安全的做法
val length = name?.length ?: 0  // 当作可空类型处理

// Java 代码
public class JavaUser {
    @Nullable
    public String getNickname() {
        return nickname;
    }
    
    @NonNull
    public String getId() {
        return id;
    }
}

// Kotlin 调用
val user = JavaUser()
val nickname: String? = user.nickname  // 可空类型
val id: String = user.id  // 非空类型

// 对象声明：单例模式
object DatabaseManager {
    init {
        println("初始化数据库")
    }
    
    fun query(sql: String) {
        println("执行查询：$sql")
    }
}

// 使用单例
DatabaseManager.query("SELECT * FROM users")

// 对象表达式：匿名对象
val clickListener = object : View.OnClickListener {
    override fun onClick(v: View?) {
        println("点击了")
    }
}

// 或者不继承任何类
val obj = object {
    val x = 10
    val y = 20
}
println(obj.x + obj.y)

// 伴生对象：类似静态成员
class User(val name: String) {
    companion object {
        const val MAX_AGE = 150
        
        fun create(name: String): User {
            return User(name)
        }
    }
}

// 使用
val user = User.create("张三")
println(User.MAX_AGE)

// Kotlin 一行
object Singleton

// 相当于 Java 的静态内部类单例
public class Singleton {
    private Singleton() {}
    
    private static class Holder {
        private static final Singleton INSTANCE = new Singleton();
    }
    
    public static Singleton getInstance() {
        return Holder.INSTANCE;
    }
}

fun setupButton() {
    var clickCount = 0
    
    button.setOnClickListener(object : View.OnClickListener {
        override fun onClick(v: View?) {
            clickCount++  // 可以修改外部变量
            println("点击次数：$clickCount")
        }
    })
}

class User private constructor(val name: String, val age: Int) {
    companion object Factory {
        fun create(name: String, age: Int): User? {
            return if (age in 0..150) User(name, age) else null
        }
    }
}

// 可以省略伴生对象的名字
val user = User.create("张三", 25)

// 也可以用名字访问
val user2 = User.Factory.create("李四", 30)

// 默认是 final 的，不能被继承
class User

// 需要 open 才能被继承
open class Animal {
    open fun makeSound() {  // 方法也需要 open
        println("动物叫")
    }
}

class Dog : Animal() {
    override fun makeSound() {  // override 隐含了 open
        println("汪汪")
    }
}

abstract class Animal {
    abstract fun eat()  // 抽象方法隐含 open
    open fun sleep() {}  // 普通方法需要显式 open
}

open class Dog : Animal() {
    override fun eat() {}  // override 的方法默认 open
    
    final override fun sleep() {}  // 不允许再被重写
}

// 用委托代替继承
interface Base {
    fun print()
}

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

// 通过委托复用 BaseImpl 的实现
class Derived(b: Base) : Base by b

// 使用
val base = BaseImpl()
val derived = Derived(base)
derived.print()  // 调用 BaseImpl 的实现

interface Base {
    fun print()
    fun printWithPrefix(prefix: String)
}

class BaseImpl : Base {
    override fun print() = println("BaseImpl")
    override fun printWithPrefix(prefix: String) = println("$prefix: BaseImpl")
}

// 类委托：把 Base 的实现委托给 b
class Derived(b: Base) : Base by b {
    // 可以选择性地重写某些方法
    override fun printWithPrefix(prefix: String) {
        println("Derived: $prefix")
    }
}

// 使用
val base = BaseImpl()
val derived = Derived(base)
derived.print()  // 调用 BaseImpl 的实现
derived.printWithPrefix("Test")  // 调用 Derived 的重写

// lazy 延迟初始化
val lazyValue: String by lazy {
    println("初始化")
    "Hello"
}
println(lazyValue)  // 第一次访问时初始化
println(lazyValue)  // 第二次直接返回

// observable 观察属性变化
var name: String by Delegates.observable("初始值") { prop, old, new ->
    println("${prop.name} 从 $old 变为 $new")
}
name = "张三"  // 触发观察者

interface Flyable {
    fun fly()
}

interface Swimmable {
    fun swim()
}

class Bird : Flyable {
    override fun fly() = println("飞翔")
}

class Fish : Swimmable {
    override fun swim() = println("游泳")
}

// 同时委托两个接口
class SuperAnimal(f: Flyable, s: Swimmable) : Flyable by f, Swimmable by s

val animal = SuperAnimal(Bird(), Fish())
animal.fly()   // 委托给 Bird
animal.swim()  // 委托给 Fish

class User {
    // 线程安全的懒加载
    val expensiveData: String by lazy {
        println("初始化昂贵的数据")
        fetchFromNetwork()
    }
    
    // 不同的线程安全模式
    val data1: String by lazy(LazyThreadSafetyMode.SYNCHRONIZED) { "线程安全" }
    val data2: String by lazy(LazyThreadSafetyMode.NONE) { "不考虑线程安全" }
}

class User {
    // 观察属性变化
    var age: Int by Delegates.observable(0) { prop, old, new ->
        println("年龄从 $old 变为 $new")
    }
    
    // 否决不合法的值
    var score: Int by Delegates.vetoable(0) { prop, old, new ->
        new in 0..100  // 只接受 0-100 的值
    }
}

val user = User()
user.age = 25    // 输出：年龄从 0 变为 25
user.score = 90  // OK
user.score = 150 // 被否决，保持 90

class Preference<T>(private val key: String, private val default: T) {
    operator fun getValue(thisRef: Any?, property: KProperty<*>): T {
        return getFromSharedPreferences(key, default)
    }
    
    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
        saveToSharedPreferences(key, value)
    }
}

// 使用自定义委托
class Settings {
    var username: String by Preference("username", "")
    var darkMode: Boolean by Preference("dark_mode", false)
}

class Example {
    // 延迟初始化属性
    val lazyValue: String by lazy {
        println("初始化中...")
        "Hello World"  // 初始化代码
    }
}

val example = Example()
println("创建对象")
// 此时还没有初始化 lazyValue

println(example.lazyValue)  // 第一次访问，执行初始化
// 输出：初始化中...
// 输出：Hello World

println(example.lazyValue)  // 第二次访问，直接返回缓存值
// 输出：Hello World（不会再输出"初始化中..."）

// 默认：线程安全，使用双重检查锁
val safe: String by lazy { "线程安全" }

// 等价于
val safe2: String by lazy(LazyThreadSafetyMode.SYNCHRONIZED) { "线程安全" }

// 不考虑线程安全，性能更好
val unsafe: String by lazy(LazyThreadSafetyMode.NONE) { "不安全" }

// 允许多个线程初始化，但只使用第一个完成的结果
val publication: String by lazy(LazyThreadSafetyMode.PUBLICATION) { "发布模式" }

class Example {
    // lazy：val，自动初始化，线程安全
    val lazyValue: String by lazy {
        computeValue()
    }
    
    // lateinit：var，手动初始化，需要自己保证
    lateinit var lateinitValue: String
    
    fun init() {
        lateinitValue = "初始化"
    }
}

class Config {
    // 配置类通常在单线程中使用，可以用 NONE 模式
    val option1: String by lazy(LazyThreadSafetyMode.NONE) { loadOption1() }
    val option2: String by lazy(LazyThreadSafetyMode.NONE) { loadOption2() }
    val option3: String by lazy(LazyThreadSafetyMode.NONE) { loadOption3() }
}

// Fragment 参数解析
class UserFragment : Fragment() {
    private val userId: String by lazy {
        arguments?.getString("user_id") ?: ""
    }
}

// ViewModel 懒加载
class MyActivity : AppCompatActivity() {
    private val viewModel: MyViewModel by lazy {
        ViewModelProvider(this).get(MyViewModel::class.java)
    }
}

// 单例实现
class DatabaseManager private constructor() {
    companion object {
        val instance: DatabaseManager by lazy {
            DatabaseManager()
        }
    }
}

data class User(var name: String, var age: Int)

val user = User("张三", 25)

// let：用 it 引用，返回代码块结果
val result1 = user.let {
    println("姓名：${it.name}")
    it.age + 10  // 返回这个值
}
println(result1)  // 35

// run：用 this 引用，返回代码块结果
val result2 = user.run {
    println("姓名：$name")  // this 可省略
    age + 10
}
println(result2)  // 35

// with：不是扩展函数，用 this 引用，返回代码块结果
val result3 = with(user) {
    println("姓名：$name")
    age + 10
}
println(result3)  // 35

// apply：用 this 引用，返回对象本身
val result4 = user.apply {
    name = "李四"  // 修改对象
    age = 30
}
println(result4)  // User(name=李四, age=30)

// also：用 it 引用，返回对象本身
val result5 = user.also {
    println("修改前：${it.name}")
    it.name = "王五"
}
println(result5)  // User(name=王五, age=30)

// 处理可空对象
val name: String? = getName()
name?.let {
    println("姓名长度：${it.length}")
    saveToDatabase(it)
}

// 限制变量作用域
val result = getDa ta().let { data ->
    // data 只在这里可见
    processData(data)
}

// 链式调用
val result = listOf(1, 2, 3, 4, 5)
    .filter { it > 2 }
    .let { filtered ->
        println("过滤后的列表：$filtered")
        filtered.sum()
    }

// 对象初始化
val user = User("张三", 25).apply {
    email = "zhangsan@example.com"
    phone = "13800138000"
}

// 视图配置
val textView = TextView(context).apply {
    text = "标题"
    textSize = 18f
    setTextColor(Color.BLACK)
}

// 链式配置
Intent(this, MainActivity::class.java).apply {
    putExtra("key1", "value1")
    putExtra("key2", "value2")
    flags = Intent.FLAG_ACTIVITY_NEW_TASK
}.let {
    startActivity(it)
}

// run 可以链式调用
val result = user?.run {
    name = "新名字"
    age + 10
}

// with 不能直接用于可空对象
// val result = with(user?) { ... }  // 编译错误

// with 适合已知非空的对象
val result = with(user) {
    println("$name，$age 岁")
    age * 2
}

// 调试输出
val numbers = mutableListOf(1, 2, 3)
    .also { println("添加前：$it") }
    .apply { add(4) }
    .also { println("添加后：$it") }

// 执行副作用
val user = createUser().also {
    log("创建了用户：${it.name}")
    sendAnalytics("user_created", it.id)
}

// 普通类：封装用户操作逻辑（行为为主，数据为辅）
class UserManager {
    // 私有属性
    private var loginStatus = false
    
    // 行为方法
    fun login(username: String, password: String): Boolean {
        // 模拟登录逻辑
        loginStatus = (username == "admin" && password == "123456")
        return loginStatus
    }
    
    fun logout() {
        loginStatus = false
        println("用户已退出登录")
    }
    
    fun isLogin(): Boolean = loginStatus
}

// 使用
fun main() {
    val manager = UserManager()
    println("登录结果：${manager.login("admin", "123456")}") // 登录结果：true
    println("当前登录状态：${manager.isLogin()}") // 当前登录状态：true
    manager.logout() // 用户已退出登录
}

// 数据类：纯数据载体（用户信息）
data class User(
    val id: Long,
    val name: String,
    val age: Int,
    val email: String? = null // 可选参数
)

// 使用
fun main() {
    val user1 = User(1, "张三", 28, "zhangsan@test.com")
    val user2 = User(1, "张三", 28, "zhangsan@test.com")
    val user3 = user1.copy(age = 29) // 复制并修改部分属性
    
    // 自动生成的toString()
    println(user1) // User(id=1, name=张三, age=28, email=zhangsan@test.com)
    // 自动生成的equals()
    println("user1 == user2：${user1 == user2}") // true
    // 解构赋值（componentN()）
    val (id, name, age) = user1
    println("解构：id=$id, name=$name, age=$age") // 解构：id=1, name=张三, age=28
}

// 密封类：限定接口返回结果的类型（仅Success/Error/Loading三种）
sealed class ApiResult<out T> {
    // 子类必须定义在同一文件内
    data class Success<out T>(val data: T) : ApiResult<T>()
    data class Error(val message: String, val code: Int) : ApiResult<Nothing>()
    object Loading : ApiResult<Nothing>() // 无数据的加载状态用object
}

// 使用：when表达式无需else（编译器检查所有分支）
fun handleResult(result: ApiResult<User>) {
    when (result) {
        is ApiResult.Success -> println("请求成功：${result.data}")
        is ApiResult.Error -> println("请求失败：${result.code} - ${result.message}")
        ApiResult.Loading -> println("请求中...")
    }
}

// 测试
fun main() {
    val successResult = ApiResult.Success(User(1, "张三", 28))
    val errorResult = ApiResult.Error("网络异常", 500)
    handleResult(successResult) // 请求成功：User(id=1, name=张三, age=28, email=null)
    handleResult(errorResult) // 请求失败：500 - 网络异常
}

// 密封接口：限定支付方式（仅微信/支付宝/银行卡）
sealed interface PayMethod {
    data class WeChatPay(val openId: String) : PayMethod
    data class AliPay(val alipayAccount: String) : PayMethod
    data class BankCardPay(val cardNo: String, val bankName: String) : PayMethod
}

// 使用
fun pay(method: PayMethod) {
    when (method) {
        is PayMethod.WeChatPay -> println("微信支付：${method.openId}")
        is PayMethod.AliPay -> println("支付宝支付：${method.alipayAccount}")
        is PayMethod.BankCardPay -> println("银行卡支付：${method.bankName}(${method.cardNo})")
    }
}

// 单例工具类：字符串处理
object StringUtils {
    fun isEmpty(str: String?): Boolean {
        return str == null || str.trim().isEmpty()
    }
    
    fun capitalizeFirstLetter(str: String): String {
        if (isEmpty(str)) return ""
        return str.substring(0, 1).uppercase() + str.substring(1)
    }
}

// 使用
fun main() {
    println(StringUtils.isEmpty("")) // true
    println(StringUtils.capitalizeFirstLetter("kotlin")) // Kotlin
}

class Order(val orderId: String, val amount: Double) {
    // 伴生对象：属于类本身，而非实例
    companion object {
        // 类级别的常量
        const val DEFAULT_CURRENCY = "CNY"
        
        // 工厂方法：创建默认订单
        fun createDefaultOrder(): Order {
            return Order("DEFAULT_${System.currentTimeMillis()}", 0.0)
        }
    }
}

// 使用：直接通过类名调用
fun main() {
    println(Order.DEFAULT_CURRENCY) // CNY
    val defaultOrder = Order.createDefaultOrder()
    println(defaultOrder) // Order(orderId=DEFAULT_1735678901234, amount=0.0)
}

// 定义接口
interface ClickListener {
    fun onClick()
}

// 使用对象表达式创建匿名实现类
fun setClickListener(listener: ClickListener) {
    listener.onClick()
}

fun main() {
    setClickListener(object : ClickListener {
        override fun onClick() {
            println("按钮被点击了")
        }
    }) // 输出：按钮被点击了
}

// 抽象类：抽取所有形状的通用逻辑（计算面积为抽象方法）
abstract class Shape {
    // 具体方法：通用逻辑
    fun draw() {
        println("开始绘制形状")
    }
    
    // 抽象方法：子类必须实现
    abstract fun calculateArea(): Double
}

// 子类1：圆形
class Circle(private val radius: Double) : Shape() {
    override fun calculateArea(): Double {
        return Math.PI * radius * radius
    }
}

// 子类2：矩形
class Rectangle(private val width: Double, private val height: Double) : Shape() {
    override fun calculateArea(): Double {
        return width * height
    }
}

// 使用
fun main() {
    val shapes: List<Shape> = listOf(Circle(2.0), Rectangle(3.0, 4.0))
    shapes.forEach { shape ->
        shape.draw()
        println("面积：${shape.calculateArea()}")
    }
    // 输出：
    // 开始绘制形状
    // 面积：12.566370614359172
    // 开始绘制形状
    // 面积：12.0
}

// 枚举类：订单状态（包含属性和方法）
enum class OrderStatus(
    val code: Int,
    val desc: String
) {
    PENDING(1, "待支付"),
    PAID(2, "已支付"),
    SHIPPED(3, "已发货"),
    COMPLETED(4, "已完成"),
    CANCELLED(5, "已取消");

    // 枚举类的方法
    fun isFinalStatus(): Boolean {
        return this == COMPLETED || this == CANCELLED
    }
}

// 使用
fun main() {
    val status = OrderStatus.PAID
    println("状态码：${status.code}，描述：${status.desc}") // 状态码：2，描述：已支付
    println("是否终态：${status.isFinalStatus()}") // 是否终态：false
    
    // 遍历所有枚举值
    OrderStatus.values().forEach {
        println("${it.name} -> ${it.desc}")
    }
}

// 外部类
class OuterClass(val outerName: String) {
    private val outerValue = 100

    // 嵌套类（无inner，不持有外部类引用）
    class NestedClass {
        fun printInfo() {
            // 无法访问外部类的outerName/outerValue
            println("这是嵌套类")
        }
    }

    // 内部类（有inner，持有外部类引用）
    inner class InnerClass {
        fun printOuterInfo() {
            // 可访问外部类的属性（包括私有）
            println("外部类名称：$outerName，外部类值：$outerValue")
            // 访问外部类的this：OuterClass.this
            println("外部类实例：${OuterClass.this}")
        }
    }
}

// 使用
fun main() {
    // 嵌套类：直接通过外部类名创建
    val nested = OuterClass.NestedClass()
    nested.printInfo() // 这是嵌套类

    // 内部类：必须通过外部类实例创建
    val outer = OuterClass("外部类实例")
    val inner = outer.InnerClass()
    inner.printOuterInfo() 
    // 输出：
    // 外部类名称：外部类实例，外部类值：100
    // 外部类实例：OuterClass@6d311334
}

// 泛型类：通用缓存工具
class CacheManager<T> {
    private val cacheMap = mutableMapOf<String, T>()

    // 存入缓存
    fun put(key: String, value: T) {
        cacheMap[key] = value
    }

    // 获取缓存
    fun get(key: String): T? {
        return cacheMap[key]
    }

    // 清空缓存
    fun clear() {
        cacheMap.clear()
    }
}

// 使用：指定不同的类型参数
fun main() {
    // 字符串缓存
    val stringCache = CacheManager<String>()
    stringCache.put("name", "Kotlin")
    println(stringCache.get("name")) // Kotlin

    // 用户对象缓存
    val userCache = CacheManager<User>()
    userCache.put("user1", User(1, "张三", 28))
    println(userCache.get("user1")) // User(id=1, name=张三, age=28, email=null)
}

// 定义接口
interface Printer {
    fun print(content: String)
}

// 接口的实现类1：控制台打印
class ConsolePrinter : Printer {
    override fun print(content: String) {
        println("控制台打印：$content")
    }
}

// 接口的实现类2：文件打印（模拟）
class FilePrinter : Printer {
    override fun print(content: String) {
        println("文件打印：$content")
    }
}

// 委托类：将Printer接口的实现委托给传入的对象
class PrintService(printer: Printer) : Printer by printer

// 使用
fun main() {
    // 委托给控制台打印
    val consoleService = PrintService(ConsolePrinter())
    consoleService.print("Hello Kotlin") // 控制台打印：Hello Kotlin

    // 委托给文件打印
    val fileService = PrintService(FilePrinter())
    fileService.print("Hello Kotlin") // 文件打印：Hello Kotlin
}

// 最简单的类定义
class User

// 带主构造函数的类
class User(val name: String, val age: Int)

// 主构造函数 + init 块
class User(val name: String, val age: Int) {
    init {
        println("创建用户：$name，年龄：$age")
    }
}

// 主构造函数 + 次构造函数
class User(val name: String) {
    var age: Int = 0
    
    // 次构造函数，必须调用主构造函数
    constructor(name: String, age: Int) : this(name) {
        this.age = age
    }
}

// 只有次构造函数，没有主构造函数
class User {
    var name: String
    var age: Int
    
    constructor(name: String) {
        this.name = name
        this.age = 0
    }
    
    constructor(name: String, age: Int) {
        this.name = name
        this.age = age
    }
}

// Kotlin 一行
class User(val name: String, val age: Int)

// 相当于 Java 的
public class User {
    private final String name;
    private final int age;
    
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() { return name; }
    public int getAge() { return age; }
}

class User(val name: String) {
    val timestamp = System.currentTimeMillis()
    
    init {
        println("第一个 init：$name")
    }
    
    val random = Math.random()
    
    init {
        println("第二个 init：$timestamp")
    }
}
// 执行顺序：主构造函数 -> timestamp 初始化 -> 第一个 init -> random 初始化 -> 第二个 init

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

// 用默认参数，更简洁
class User(val name: String, val age: Int = 0)

// 定义数据类
data class User(val name: String, val age: Int)

// 自动生成的功能
val user1 = User("张三", 25)
val user2 = User("张三", 25)

// toString()：输出可读的字符串
println(user1)  // User(name=张三, age=25)

// equals()：比较内容是否相等
println(user1 == user2)  // true

// hashCode()：可以用作 HashMap 的 key
val map = hashMapOf(user1 to "数据")

// copy()：创建副本，可以修改部分属性
val user3 = user1.copy(age = 26)
println(user3)  // User(name=张三, age=26)

// componentN()：解构声明
val (name, age) = user1
println("$name，$age 岁")  // 张三，25 岁

data class User(val name: String, val age: Int, val city: String)

val user1 = User("张三", 25, "北京")
val user2 = user1.copy(age = 26)  // 只改年龄
val user3 = user1.copy(city = "上海")  // 只改城市

data class Result(val success: Boolean, val message: String, val data: Any?)

fun getData(): Result {
    return Result(true, "成功", listOf(1, 2, 3))
}

// 解构声明
val (success, message, data) = getData()
if (success) {
    println(message)
}

// 遍历 Map
val map = mapOf("a" to 1, "b" to 2)
for ((key, value) in map) {
    println("$key = $value")
}

// 网络响应模型
data class ApiResponse<T>(
    val code: Int,
    val message: String,
    val data: T?
)

// UI 状态类
data class UiState(
    val isLoading: Boolean = false,
    val error: String? = null,
    val data: List<String> = emptyList()
)

// 定义密封类表示网络请求结果
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("加载中...")
    // 不需要 else，因为已经覆盖了所有情况
}

// 如果新增子类，when 会报编译错误，提醒你补充分支

// 枚举：每个值都一样
enum class Status {
    SUCCESS, ERROR, LOADING
}

// 密封类：每个子类可以不同
sealed class Result {
    data class Success(val data: String) : Result()  // 携带数据
    data class Error(val code: Int, val message: String) : Result()  // 携带错误信息
    object Loading : Result()  // 单例对象
}

// UI 状态
sealed class UiState {
    object Loading : UiState()
    data class Success(val users: List<User>) : UiState()
    data class Error(val message: String) : UiState()
    object Empty : UiState()
}

// 导航事件
sealed class NavigationEvent {
    object NavigateBack : NavigationEvent()
    data class NavigateToDetail(val id: String) : NavigationEvent()
    data class NavigateToWeb(val url: String) : NavigationEvent()
}

// 表单验证结果
sealed class ValidationResult {
    object Valid : ValidationResult()
    data class Invalid(val errors: List<String>) : ValidationResult()
}

// 伴生对象可以实现接口
interface Factory<T> {
    fun create(): T
}

class User {
    companion object : Factory<User> {
        override fun create() = User()
    }
}

// 给伴生对象定义扩展函数
fun User.Companion.createDefault() = User()