多态与扩展机制

// 定义一个可被继承的抽象图形基类
// abstract 类天然是 open 的，无需重复声明
abstract class Shape(val name: String) {
 
    // abstract 方法必须在子类中被重写
    // 返回图形面积，单位为平方单位
    abstract fun area(): Double
 
    // open 方法：允许子类选择性重写
    // 提供默认的描述信息，子类可以覆盖
    open fun describe(): String {
        // 默认实现：输出图形名称和面积
        return "Shape: $name, Area: ${"%.2f".format(area())}"
    }
 
    // 非 open 方法：final，不可被重写
    // 保证核心日志逻辑不被子类篡改
    fun printInfo() {
        println(describe())
    }
}
 
// 使用 : Shape(参数) 语法调用父类构造器
// Circle 是一个具体（concrete）的子类
class Circle(val radius: Double) : Shape("Circle") {
 
    // 必须使用 override 关键字，且编译器强制检查
    // 若父类方法非 open/abstract，则编译报错
    override fun area(): Double {
        // π × r²，使用 Kotlin 标准库常量 Math.PI
        return Math.PI * radius * radius
    }
 
    // 选择性重写 describe()，添加半径信息
    override fun describe(): String {
        // super.describe() 调用父类实现，实现复用
        return "${super.describe()}, Radius: $radius"
    }
}
 
// Rectangle 子类，继承 Shape
class Rectangle(val width: Double, val height: Double) : Shape("Rectangle") {
 
    override fun area(): Double {
        // 长方形面积 = 宽 × 高
        return width * height
    }
    // 未重写 describe()，使用父类默认实现
}
 
// 演示多态的核心用法
fun main() {
    // 声明为父类类型 Shape，但实际指向子类对象
    // 这正是子类型多态的经典用法：面向接口/抽象编程
    val shapes: List<Shape> = listOf(
        Circle(5.0),          // 实际类型：Circle
        Rectangle(4.0, 6.0),  // 实际类型：Rectangle
        Circle(3.0)            // 实际类型：Circle
    )
 
    // 遍历时，JVM 根据实际类型动态分派调用正确的 area()
    for (shape in shapes) {
        shape.printInfo() // 静态类型是 Shape，但调用的是子类实现
    }
}

// 使用 final override 终止多态继承链
// 任何继承 Circle 的子类都无法再重写 area()
class ImmutableCircle(radius: Double) : Circle(radius) {
    final override fun area(): Double {
        // 使用 super 调用父类 Circle 的实现
        return super.area()
    }
}

// 演示静态类型 vs 运行时类型的核心区别
open class Animal {
    // open 方法，参与动态绑定，使用 invokevirtual 调用
    open fun sound(): String = "..."
 
    // companion object 中的函数对应 Java 静态方法
    // 使用静态绑定，不参与多态
    companion object {
        fun category(): String = "Animal"
    }
}
 
class Dog : Animal() {
    // override 方法：运行时会被动态分派到这里
    override fun sound(): String = "Woof"
 
    companion object {
        // 即使子类定义了同名"静态方法"，也不会覆盖父类
        // 这是静态绑定不参与多态的直接体现
        fun category(): String = "Dog"
    }
}
 
class Cat : Animal() {
    override fun sound(): String = "Meow"
}
 
fun demonstrateDispatch() {
    // 声明为父类 Animal 类型，编译器看到的是 Animal
    val animal: Animal = Dog()
 
    // ✅ 动态绑定：运行时类型是 Dog，输出 "Woof"
    // JVM 在运行时查找 Dog 的 VTable，找到 Dog.sound()
    println(animal.sound())
 
    // ⚠️ 静态绑定：编译器看到 Animal 类型，直接调用 Animal.category()
    // 即使 animal 实际是 Dog，也输出 "Animal"
    // 这是 Kotlin/Java 中"静态方法不参与多态"的典型陷阱
    println(Animal.category())
 
    // 多态集合遍历：每个元素的 sound() 调用都通过各自的 VTable
    val animals: List<Animal> = listOf(Dog(), Cat(), Dog())
    animals.forEach { println(it.sound()) } // 输出: Woof, Meow, Woof
}

// sealed class 让编译器知道 Shape 的所有子类
// 结合 when 表达式，可以实现穷尽性检查（exhaustive check）
sealed class Shape2
 
// data class 自动生成 equals/hashCode/copy/toString
data class Circle2(val radius: Double) : Shape2()
data class Rectangle2(val width: Double, val height: Double) : Shape2()
data class Triangle2(val base: Double, val height: Double) : Shape2()
 
// 使用 when 表达式进行类型分支：这是 Kotlin 中处理
// sealed class 多态的惯用模式，编译器会强制覆盖所有子类
fun computeArea(shape: Shape2): Double = when (shape) {
    // 每个分支中，shape 被智能转换为对应子类类型
    // 无需手动强转，编译器自动推断
    is Circle2    -> Math.PI * shape.radius * shape.radius   // shape: Circle2
    is Rectangle2 -> shape.width * shape.height               // shape: Rectangle2
    is Triangle2  -> 0.5 * shape.base * shape.height          // shape: Triangle2
    // sealed class 保证 when 是穷尽的，无需 else 分支
}

open class Base {
    // ⚠️ 危险行为：在构造器中调用 open 方法
    // 此时子类尚未完成初始化，但 VTable 已指向子类实现
    init {
        // JVM 已通过 VTable 确定调用 Derived.value
        // 但 Derived 的属性此时尚未初始化！
        println("Base init, value = ${value()}")
    }
 
    // open 方法，子类可重写
    open fun value(): Int = 0
}
 
class Derived : Base() {
    // 这个属性在 Base 的 init 块执行时还没有被赋值
    // JVM 中 Int 字段的默认零值会被读取
    private val number: Int = 42
 
    // 重写父类方法，返回 number 字段的值
    override fun value(): Int = number
}
 
fun main() {
    val d = Derived()
    // 构造器输出: "Base init, value = 0"  ← 而非 42！
    // 最终访问:   d.value() = 42
    println("Final value = ${d.value()}")
}

open class Printer {
    open fun print() = println("Printer")
    fun execute() = print()
}
 
class LaserPrinter : Printer() {
    override fun print() = println("LaserPrinter")
}
 
fun main() {
    val p: Printer = LaserPrinter()
    p.execute()
}

// 定义一个泛型容器类,T 是类型参数
class Box<T>(
    private var content: T  // T 可以作为属性类型使用
) {
    // T 可以作为方法返回类型
    fun get(): T = content
    
    // T 可以作为方法参数类型
    fun set(value: T) {
        content = value
    }
    
    // T 可以用于方法内部的局部变量
    fun replaceAndReturn(newValue: T): T {
        val old = content  // old 的类型推断为 T
        content = newValue
        return old
    }
}
 
// 使用时提供具体类型参数
val intBox = Box<Int>(42)           // T 被绑定为 Int
val stringBox = Box<String>("hello") // T 被绑定为 String
 
// Kotlin 支持类型推断,可以省略显式类型参数
val inferredBox = Box(3.14)  // 编译器推断 T 为 Double

// 定义泛型接口,支持多个类型参数
interface Transformer<I, O> {
    fun transform(input: I): O  // I 和 O 是两个独立的类型参数
}
 
// 实现泛型接口时,可以指定具体类型
class StringToIntTransformer : Transformer<String, Int> {
    override fun transform(input: String): Int = input.length
}
 
// 也可以保持泛型,将类型参数传递给接口
class IdentityTransformer<T> : Transformer<T, T> {
    override fun transform(input: T): T = input
}

// 泛型函数的类型参数声明在函数名之前
fun <T> createList(vararg elements: T): List<T> {
    return elements.toList()  // 返回类型推断为 List<T>
}
 
// 调用时可以显式指定类型参数
val numbers = createList<Int>(1, 2, 3)
 
// 通常编译器可以从参数推断类型
val words = createList("a", "b", "c")  // 推断为 List<String>
 
// 更复杂的例子:交换函数
fun <T> swap(a: T, b: T): Pair<T, T> {
    return Pair(b, a)  // Pair 也是泛型类,接收两个类型参数
}

// 约束 T 必须是 Comparable<T> 的子类型
fun <T : Comparable<T>> max(a: T, b: T): T {
    return if (a > b) a else b  // 因为 T 实现了 Comparable,可以使用 > 运算符
}
 
// 使用示例
val maxInt = max(10, 20)        // Int 实现了 Comparable<Int>
val maxString = max("a", "z")   // String 实现了 Comparable<String>
// val maxBox = max(Box(1), Box(2))  // 编译错误: Box 未实现 Comparable

// T 必须同时实现 Comparable 和 Appendable
fun <T> processData(data: T): String 
    where T : Comparable<T>, 
          T : Appendable {
    // 可以调用 T 上的 compareTo 和 append 方法
    return data.toString()
}

open class Animal
class Dog : Animal()
 
val dogBox: Box<Dog> = Box(Dog())
// val animalBox: Box<Animal> = dogBox  // 编译错误!不变性

val animalBox: Box<Animal> = dogBox  // 假设这是允许的
animalBox.set(Animal())  // 现在向 Box 中放入 Animal
val dog: Dog = dogBox.get()  // 但原始引用期望取出 Dog!运行时错误

// Producer<T> 只产出 T,不消费 T
class Producer<out T>(private val value: T) {
    fun produce(): T = value  // 只能在 out 位置使用 T
    // fun consume(item: T) {}  // 编译错误!T 不能在 in 位置
}
 
val dogProducer: Producer<Dog> = Producer(Dog())
val animalProducer: Producer<Animal> = dogProducer  // 合法!协变
val animal: Animal = animalProducer.produce()  // 安全:取出的 Dog 可以赋值给 Animal

// Consumer<T> 只消费 T,不产出 T
class Consumer<in T> {
    fun consume(item: T) {  // 只能在 in 位置使用 T
        // 处理 item
    }
    // fun produce(): T  // 编译错误!T 不能在 out 位置
}
 
val animalConsumer: Consumer<Animal> = Consumer()
val dogConsumer: Consumer<Dog> = animalConsumer  // 合法!逆变
dogConsumer.consume(Dog())  // 安全:传入的 Dog 会被当作 Animal 处理

val dogs: List<Dog> = listOf(Dog(), Dog())
val animals: List<Animal> = dogs  // 合法!List 是协变的
 
val mutableDogs: MutableList<Dog> = mutableListOf(Dog())
// val mutableAnimals: MutableList<Animal> = mutableDogs  // 编译错误!MutableList 不变

val stringList = listOf("a", "b")
val intList = listOf(1, 2)
 
// 运行时两者都是 ArrayList,类型参数被擦除
println(stringList::class)  // class java.util.ArrayList
println(intList::class)     // class java.util.ArrayList
 
// 无法进行类型检查
// if (stringList is List<String>) {}  // 编译错误:无法检查被擦除的类型

// inline + reified 保留类型信息
inline fun <reified T> isInstance(value: Any): Boolean {
    return value is T  // 合法!T 的类型信息被具体化
}
 
// 使用示例
println(isInstance<String>("hello"))  // true
println(isInstance<Int>("hello"))     // false
 
// 实际编译后,编译器会将类型参数替换为具体类型
// isInstance<String>("hello") -> "hello" is String

// 标准库中的 filterIsInstance 实现
inline fun <reified T> Iterable<*>.filterIsInstance(): List<T> {
    return filterIsInstanceTo(ArrayList<T>())
}
 
val mixed: List<Any> = listOf(1, "two", 3.0, "four")
val strings: List<String> = mixed.filterIsInstance<String>()  // ["two", "four"]

// 通用的栈数据结构
class Stack<T> {
    private val elements = mutableListOf<T>()  // 内部使用泛型 List
    
    // 入栈操作,接受 T 类型参数
    fun push(element: T) {
        elements.add(element)
    }
    
    // 出栈操作,返回 T 类型或 null
    fun pop(): T? {
        return if (elements.isEmpty()) null 
               else elements.removeAt(elements.lastIndex)
    }
    
    // 查看栈顶元素,不移除
    fun peek(): T? = elements.lastOrNull()
    
    // 检查栈是否为空
    val isEmpty: Boolean get() = elements.isEmpty()
    
    // 获取栈的大小
    val size: Int get() = elements.size
    
    // 支持函数式操作:遍历所有元素
    inline fun forEach(action: (T) -> Unit) {
        elements.forEach(action)  // 将操作委托给底层 List
    }
}
 
// 单一实现,适用于所有类型
val intStack = Stack<Int>()
intStack.push(1)
intStack.push(2)
println(intStack.pop())  // 2
 
val stringStack = Stack<String>()
stringStack.push("hello")
stringStack.push("world")
stringStack.forEach { println(it.uppercase()) }  // HELLO, WORLD

// 泛型的 Result 类型,封装成功或失败
sealed class Result<out T> {
    data class Success<T>(val data: T) : Result<T>()
    data class Error(val exception: Exception) : Result<Nothing>()
    
    // 提供 map 操作,转换成功结果
    inline fun <R> map(transform: (T) -> R): Result<R> = when (this) {
        is Success -> Success(transform(data))  // 转换成功值
        is Error -> this  // 保持错误状态
    }
}
 
// 泛型的异步操作包装器
class AsyncOperation<T>(private val operation: () -> T) {
    // 执行操作并返回 Result
    fun execute(): Result<T> = try {
        Result.Success(operation())  // 成功时包装结果
    } catch (e: Exception) {
        Result.Error(e)  // 失败时包装异常
    }
}
 
// 使用示例:组合泛型组件
val fetchData = AsyncOperation { 
    // 模拟网络请求
    "data from server" 
}
 
val result = fetchData.execute()  // Result<String>
val uppercaseResult = result.map { it.uppercase() }  // Result<String>
 
when (uppercaseResult) {
    is Result.Success -> println(uppercaseResult.data)
    is Result.Error -> println("Failed: ${uppercaseResult.exception}")
}

// 定义一个二维向量类
data class Vector2D(val x: Double, val y: Double) {
    
    // 重载 + 操作符,对应 plus 函数
    operator fun plus(other: Vector2D): Vector2D {
        return Vector2D(
            x = this.x + other.x,  // 分量相加
            y = this.y + other.y
        )
    }
    
    // 重载 - 操作符,对应 minus 函数
    operator fun minus(other: Vector2D): Vector2D {
        return Vector2D(this.x - other.x, this.y - other.y)
    }
    
    // 重载 * 操作符,实现标量乘法
    operator fun times(scalar: Double): Vector2D {
        return Vector2D(x * scalar, y * scalar)
    }
    
    // 重载一元 - 操作符,对应 unaryMinus 函数
    operator fun unaryMinus(): Vector2D {
        return Vector2D(-x, -y)  // 取反每个分量
    }
}
 
// 使用操作符语法
val v1 = Vector2D(3.0, 4.0)
val v2 = Vector2D(1.0, 2.0)
 
val sum = v1 + v2        // 等价于 v1.plus(v2)
val diff = v1 - v2       // 等价于 v1.minus(v2)
val scaled = v1 * 2.0    // 等价于 v1.times(2.0)
val negated = -v1        // 等价于 v1.unaryMinus()
 
println(sum)     // Vector2D(x=4.0, y=6.0)
println(negated) // Vector2D(x=-3.0, y=-4.0)

class Matrix(private val data: Array<DoubleArray>) {
    
    // 索引操作符:mat[i, j]
    operator fun get(row: Int, col: Int): Double {
        return data[row][col]  // 委托给底层数组
    }
    
    // 索引赋值操作符:mat[i, j] = value
    operator fun set(row: Int, col: Int, value: Double) {
        data[row][col] = value
    }
    
    // in 操作符:value in matrix
    operator fun contains(value: Double): Boolean {
        return data.any { row -> value in row }  // 检查是否包含某值
    }
    
    // 范围操作符:matrix1..matrix2
    operator fun rangeTo(other: Matrix): List<Matrix> {
        // 生成从 this 到 other 的插值矩阵序列
        return listOf(this, other)  // 简化实现
    }
}
 
val mat = Matrix(arrayOf(
    doubleArrayOf(1.0, 2.0),
    doubleArrayOf(3.0, 4.0)
))
 
println(mat[0, 1])   // 2.0,调用 get
mat[1, 0] = 5.0      // 调用 set
println(5.0 in mat)  // true,调用 contains

val v = Vector2D(1.0, 2.0)
val result = -v * 2.0 + Vector2D(3.0, 4.0)
// 等价于 (v.unaryMinus().times(2.0)).plus(Vector2D(3.0, 4.0))
// 即 ((-v) * 2.0) + Vector2D(3.0, 4.0)

// 为 Int 扩展 * 操作符,支持 Int * Vector2D
operator fun Int.times(vector: Vector2D): Vector2D {
    val scalar = this.toDouble()  // 转换为 Double
    return Vector2D(vector.x * scalar, vector.y * scalar)
}
 
// 为 String 扩展 * 操作符,实现重复字符串
operator fun String.times(n: Int): String {
    return this.repeat(n)  // 调用标准库的 repeat
}
 
// 使用扩展操作符
val scaled = 3 * Vector2D(1.0, 2.0)  // Vector2D(3.0, 6.0)
val repeated = "ab" * 3              // "ababab"

// 好的实践:+ 用于组合/合并语义
data class Config(val settings: Map<String, String>) {
    operator fun plus(other: Config): Config {
        return Config(settings + other.settings)  // 合并配置
    }
}
 
// 不好的实践:* 用于完全无关的操作
data class User(val name: String) {
    // ❌ 混淆:* 通常表示乘法或重复,而非删除操作
    operator fun times(other: User): Unit {
        // 删除另一个用户???
    }
}

class Printer {
    
    // 重载 print 函数:处理 Int
    fun print(value: Int) {
        println("Integer: $value")
    }
    
    // 重载 print 函数:处理 String
    fun print(value: String) {
        println("String: $value")
    }
    
    // 重载 print 函数:处理多个 Int
    fun print(vararg values: Int) {
        println("Multiple integers: ${values.joinToString()}")
    }
    
    // 重载 print 函数:处理泛型 List
    fun <T> print(list: List<T>) {
        println("List of ${list.size} elements: $list")
    }
}
 
val printer = Printer()
printer.print(42)              // 调用 print(Int)
printer.print("hello")         // 调用 print(String)
printer.print(1, 2, 3)         // 调用 print(vararg Int)
printer.print(listOf(1, 2))    // 调用 print(List<T>)

open class Animal
class Dog : Animal()
 
fun process(animal: Animal) {
    println("Processing animal")
}
 
fun process(dog: Dog) {
    println("Processing dog")
}
 
val dog: Dog = Dog()
val animal: Animal = dog  // 静态类型为 Animal,运行时类型为 Dog
 
process(dog)     // "Processing dog" - 静态类型是 Dog
process(animal)  // "Processing animal" - 静态类型是 Animal,即使运行时是 Dog

// 使用默认参数替代多个重载
fun connect(
    host: String,
    port: Int = 8080,         // 默认端口
    timeout: Int = 5000,      // 默认超时
    useSSL: Boolean = false   // 默认不使用 SSL
) {
    println("Connecting to $host:$port (SSL=$useSSL, timeout=$timeout)")
}
 
// 可以省略任何默认参数
connect("localhost")                      // 使用所有默认值
connect("example.com", port = 443)        // 使用命名参数指定部分参数
connect("db.server", 3306, useSSL = true) // 混合使用

// 实现 Comparable 接口
data class Version(val major: Int, val minor: Int, val patch: Int) 
    : Comparable<Version> {
    
    // compareTo 是 Comparable 的唯一抽象方法
    override fun compareTo(other: Version): Int {
        // 先比较主版本号
        if (this.major != other.major) {
            return this.major - other.major
        }
        // 再比较次版本号
        if (this.minor != other.minor) {
            return this.minor - other.minor
        }
        // 最后比较补丁版本号
        return this.patch - other.patch
    }
}
 
val v1 = Version(1, 2, 3)
val v2 = Version(1, 3, 0)
 
println(v1 < v2)   // true,自动调用 compareTo
println(v1 >= v2)  // false
println(v1 == v2)  // false,使用 data class 的 equals
 
// 可以用于排序
val versions = listOf(
    Version(2, 0, 0),
    Version(1, 5, 2),
    Version(1, 5, 1)
)
val sorted = versions.sorted()  // 自动使用 compareTo
println(sorted)  // [Version(1,5,1), Version(1,5,2), Version(2,0,0)]

data class Point(val x: Int, val y: Int)
 
val p1 = Point(1, 2)
val p2 = Point(1, 2)
val p3 = p1
 
println(p1 == p2)   // true,调用 equals,比较值
println(p1 === p2)  // false,比较引用,不同对象
println(p1 === p3)  // true,相同引用

// 定义一个可调用的类
class Greeter(private val greeting: String) {
    
    // 重载 invoke 操作符
    operator fun invoke(name: String) {
        println("$greeting, $name!")
    }
    
    // 重载不同参数的 invoke
    operator fun invoke(firstName: String, lastName: String) {
        println("$greeting, $firstName $lastName!")
    }
}
 
val hello = Greeter("Hello")
hello("World")          // "Hello, World!" - 像函数一样调用
hello("John", "Doe")    // "Hello, John Doe!"
 
// 更复杂的例子:HTML DSL
class HTML {
    private val content = StringBuilder()
    
    // invoke 接收 lambda,构建嵌套结构
    operator fun invoke(build: HTML.() -> Unit): String {
        this.build()  // 执行构建逻辑
        return content.toString()
    }
    
    fun tag(name: String, text: String) {
        content.append("<$name>$text</$name>\n")
    }
}
 
val html = HTML()
val page = html {  // 调用 invoke(lambda)
    tag("h1", "Title")
    tag("p", "Paragraph")
}
println(page)
// <h1>Title</h1>
// <p>Paragraph</p>

// 定义"可序列化"类型类接口
interface Serializable<T> {
    fun serialize(value: T): String       // 序列化方法
    fun deserialize(str: String): T       // 反序列化方法
}
 
// 为 Int 提供实现
object IntSerializer : Serializable<Int> {
    override fun serialize(value: Int): String = value.toString()
    override fun deserialize(str: String): Int = str.toInt()
}
 
// 为 List<Int> 提供实现
object IntListSerializer : Serializable<List<Int>> {
    override fun serialize(value: List<Int>): String {
        return value.joinToString(",")  // 用逗号分隔
    }
    override fun deserialize(str: String): List<Int> {
        return str.split(",").map { it.toInt() }
    }
}
 
// 通用的序列化函数,接收类型类实例
fun <T> save(value: T, serializer: Serializable<T>): String {
    return serializer.serialize(value)
}
 
fun <T> load(str: String, serializer: Serializable<T>): T {
    return serializer.deserialize(str)
}
 
// 使用类型类
val savedInt = save(42, IntSerializer)          // "42"
val loadedInt = load("100", IntSerializer)      // 100
 
val savedList = save(listOf(1, 2, 3), IntListSerializer)  // "1,2,3"
val loadedList = load("4,5,6", IntListSerializer)         // [4, 5, 6]

// 使用扩展函数模拟类型类约束
context(Serializable<T>)  // 实验性:上下文接收者
fun <T> T.toJson(): String = serialize(this)
 
context(Serializable<T>)
fun <T> String.fromJson(): T = deserialize(this)
 
// 在提供 Serializable<Int> 上下文的作用域内使用
with(IntSerializer) {
    val json = 42.toJson()       // "42"
    val value = "100".fromJson() // 100
}

// 定义比较策略类型类
interface Comparator<T> {
    fun compare(a: T, b: T): Int
}
 
// 为 String 定义不区分大小写的比较
object CaseInsensitiveComparator : Comparator<String> {
    override fun compare(a: String, b: String): Int {
        return a.lowercase().compareTo(b.lowercase())
    }
}
 
// 通用排序函数,接收比较策略
fun <T> List<T>.sortedWith(comparator: Comparator<T>): List<T> {
    return this.sortedWith { a, b -> comparator.compare(a, b) }
}
 
val words = listOf("Banana", "apple", "Cherry")
val sorted = words.sortedWith(CaseInsensitiveComparator)
println(sorted)  // [apple, Banana, Cherry]

class Producer<out T>(val value: T)
class Consumer<in T>
class Box<T>(var value: T)
 
val dogProducer: Producer<Dog> = Producer(Dog())
val animalProducer: Producer<Animal> = dogProducer  // (A)
 
val animalConsumer: Consumer<Animal> = Consumer()
val dogConsumer: Consumer<Dog> = animalConsumer     // (B)
 
val dogBox: Box<Dog> = Box(Dog())
val animalBox: Box<Animal> = dogBox                 // (C)

data class Vec(val x: Int) {
    operator fun plus(other: Vec) = Vec(x + other.x)
    operator fun times(n: Int) = Vec(x * n)
    operator fun unaryMinus() = Vec(-x)
}
 
val result = -Vec(2) * 3 + Vec(5)

// 基础语法结构
fun ReceiverType.extensionFunctionName(parameters): ReturnType {
    // 函数体中,this 指向 ReceiverType 的实例
    return result
}
 
// 实际示例:为 String 类添加扩展函数
fun String.removeWhitespace(): String {
    return this.replace("\\s".toRegex(), "") // this 指向调用该函数的 String 对象
}
 
// 使用扩展函数
fun main() {
    val text = "Hello World"
    val result = text.removeWhitespace() // 像调用成员函数一样调用
    println(result) // 输出: HelloWorld
}

// 为 List<Int> 添加计算平均值的扩展函数
fun List<Int>.average(): Double {
    if (isEmpty()) return 0.0 // 省略 this.isEmpty()
    return sum().toDouble() / size // 省略 this.sum() 和 this.size
}
 
// 使用示例
fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)
    println(numbers.average()) // 输出: 3.0
}

// 1. 顶层扩展函数 - 全局可用
fun String.capitalizeWords(): String {
    return split(" ").joinToString(" ") { 
        it.replaceFirstChar { char -> char.uppercase() } 
    }
}
 
// 2. 类内部的扩展函数 - 仅在类内部可用
class StringProcessor {
    // 这个扩展函数只能在 StringProcessor 类内部使用
    private fun String.reverse(): String {
        return this.reversed()
    }
    
    fun process(text: String): String {
        return text.reverse() // 只能在类内部调用
    }
}
 
// 3. 局部扩展函数 - 仅在函数作用域内可用
fun demonstrate() {
    // 这个扩展函数只在 demonstrate 函数内部有效
    fun Int.square(): Int = this * this
    
    println(5.square()) // 输出: 25
}

open class Shape
class Circle : Shape()
 
// 为 Shape 定义扩展函数
fun Shape.getName(): String = "Shape"
 
// 为 Circle 定义扩展函数
fun Circle.getName(): String = "Circle"
 
fun main() {
    val shape: Shape = Circle() // 声明类型是 Shape,实际类型是 Circle
    println(shape.getName()) // 输出: "Shape" 而非 "Circle"
    // 扩展函数根据变量的声明类型(编译期类型)解析,而非运行时类型
}

// Kotlin 源代码
fun String.addPrefix(prefix: String): String {
    return "$prefix$this"
}
 
// 等价的 Java 字节码概念(伪代码)
public static String addPrefix(String $receiver, String prefix) {
    return prefix + $receiver;
}
 
// 调用方式
val result = "World".addPrefix("Hello ")
// 编译后实际调用: StringExtensionsKt.addPrefix("World", "Hello ")

open class Animal {
    open fun sound() = "Some sound" // 成员函数,支持多态
}
 
class Dog : Animal() {
    override fun sound() = "Bark" // 覆盖父类方法
}
 
// 扩展函数,无法被覆盖
fun Animal.description() = "Animal extension"
fun Dog.description() = "Dog extension"
 
fun printInfo(animal: Animal) {
    println(animal.sound())       // 多态调用,输出: Bark
    println(animal.description()) // 静态解析,输出: Animal extension
}
 
fun main() {
    val dog = Dog()
    printInfo(dog)
}

class MyClass {
    fun existingFunction() {
        println("Member function") // 类的成员函数
    }
}
 
// 尝试定义同名同签名的扩展函数
fun MyClass.existingFunction() {
    println("Extension function") // 这个扩展函数会被忽略
}
 
fun main() {
    val obj = MyClass()
    obj.existingFunction() // 输出: "Member function"
    // 成员函数始终优先,扩展函数永远不会被调用
}

class Calculator {
    fun add(a: Int, b: Int): Int = a + b // 成员函数:两个参数
}
 
// 扩展函数:三个参数,构成重载
fun Calculator.add(a: Int, b: Int, c: Int): Int {
    return a + b + c
}
 
fun main() {
    val calc = Calculator()
    println(calc.add(1, 2))       // 调用成员函数,输出: 3
    println(calc.add(1, 2, 3))    // 调用扩展函数,输出: 6
}

// 为可空的 String? 定义扩展函数
fun String?.isNullOrBlank(): Boolean {
    // this 的类型是 String?,可能为 null
    return this == null || this.isBlank()
}
 
fun main() {
    val text1: String? = null
    val text2: String? = "  "
    val text3: String? = "Hello"
    
    println(text1.isNullOrBlank()) // true - 处理 null 情况
    println(text2.isNullOrBlank()) // true - 处理空白字符串
    println(text3.isNullOrBlank()) // false - 正常字符串
    
    // 即使 text1 是 null,也可以安全调用扩展函数,不会抛出 NPE
}

// 为 Any? 定义扩展函数,将对象转换为安全的字符串表示
fun Any?.toSafeString(): String {
    return when {
        this == null -> "null"           // 处理 null 情况
        this is String -> "\"$this\""    // 字符串加引号
        else -> this.toString()          // 其他类型调用 toString()
    }
}
 
fun main() {
    val obj1: Any? = null
    val obj2: Any? = "Hello"
    val obj3: Any? = 42
    
    // 无需使用 ?. 安全调用
    println(obj1.toSafeString()) // 输出: null
    println(obj2.toSafeString()) // 输出: "Hello"
    println(obj3.toSafeString()) // 输出: 42
}

// 标准库中的实际实现(简化版)
public inline fun <T, R> T?.let(block: (T) -> R): R? {
    // this 可能为 null
    return if (this == null) null else block(this)
}
 
// 实际使用场景
fun processUser(name: String?) {
    name?.let { 
        // 只有当 name 不为 null 时才执行这个代码块
        println("Processing user: $it")
        // 在这个代码块中,it 的类型是 String(非空)
    }
}

// 非空接收者扩展
fun String.addExclamation(): String {
    return "$this!" // this 是 String 类型(非空)
}
 
// 可空接收者扩展
fun String?.addExclamationSafe(): String {
    return if (this != null) "$this!" else "null!" // this 是 String? 类型
}
 
fun main() {
    val text1: String = "Hello"
    val text2: String? = null
    
    println(text1.addExclamation())      // 输出: Hello!
    // println(text2.addExclamation())   // 编译错误:String? 不能调用 String 的扩展
    
    println(text1.addExclamationSafe())  // 输出: Hello!
    println(text2.addExclamationSafe())  // 输出: null!
}

// 正确的扩展属性:通过计算获得值
val String.lastChar: Char
    get() = this[length - 1] // 必须提供 getter,通过计算返回值
 
// 错误示例:尝试使用幕后字段
val String.cachedLength: Int = this.length // 编译错误!
// Error: Extension property cannot have a backing field
 
// 错误示例:尝试在 getter 中使用 field 关键字
val String.upperCaseCache: String
    get() = field ?: this.uppercase() // 编译错误!
// Error: Unresolved reference: field

// Kotlin 源代码
val String.lastChar: Char
    get() = this[length - 1]
 
// 编译后等价的 Java 伪代码
public static char getLastChar(String $receiver) {
    return $receiver.charAt($receiver.length() - 1);
}
 
// 调用方式
val char = "Hello".lastChar
// 实际字节码调用: StringExtensionsKt.getLastChar("Hello")

// 为 List<T> 添加计算属性:获取倒数第二个元素
val <T> List<T>.penultimate: T
    get() {
        if (size < 2) throw NoSuchElementException("List has less than 2 elements")
        return this[size - 2] // 基于现有的 size 和索引访问计算
    }
 
// 为 Int 添加计算属性:判断是否为偶数
val Int.isEven: Boolean
    get() = this % 2 == 0 // 通过取模运算计算
 
// 为 String 添加计算属性:获取所有元音字母
val String.vowels: String
    get() = this.filter { it.lowercaseChar() in "aeiou" } // 通过过滤计算
 
fun main() {
    val list = listOf(1, 2, 3, 4, 5)
    println(list.penultimate) // 输出: 4
    
    println(42.isEven)        // 输出: true
    println(17.isEven)        // 输出: false
    
    println("Hello World".vowels) // 输出: eoo
}

// 函数风格:适用于有明显计算成本或副作用的操作
fun String.extractEmails(): List<String> {
    val emailPattern = "[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}".toRegex()
    return emailPattern.findAll(this).map { it.value }.toList()
}
 
// 属性风格:适用于简单、快速、无副作用的访问
val String.wordCount: Int
    get() = split("\\s+".toRegex()).size
 
fun main() {
    val text = "Contact us at info@example.com or support@test.org"
    
    // 函数调用:暗示有计算过程
    val emails = text.extractEmails()
    
    // 属性访问:感觉像是直接访问字段
    val count = text.wordCount
}

// 只读扩展属性 (val)
val String.indices: IntRange
    get() = 0 until length // 只有 getter
 
// 可变扩展属性 (var) - 实际上是对现有可变状态的封装
var StringBuilder.firstChar: Char
    get() = this[0]                    // getter: 读取第一个字符
    set(value) { this[0] = value }     // setter: 修改第一个字符
 
fun main() {
    val str = "Hello"
    println(str.indices) // 输出: 0..4
    
    val builder = StringBuilder("Hello")
    println(builder.firstChar) // 输出: H
    
    builder.firstChar = 'J'    // 通过 setter 修改
    println(builder)           // 输出: Jello
    
    // 底层操作的是 StringBuilder 的内部状态,而非扩展属性自己的字段
}

// 为不可变的 String 定义 var 扩展属性 - 这在逻辑上是不可能的
var String.firstChar: Char
    get() = this[0]
    set(value) {
        // 无法实现!String 是不可变的,无法修改其内容
        // this[0] = value // 编译错误: No set method providing array access
    }
 
// 唯一的"变通"方式是返回新对象,但这已经偏离了属性赋值的语义
var String.capitalized: String
    get() = this.replaceFirstChar { it.uppercase() }
    set(value) {
        // 这个 setter 实际上无法改变 this 的值
        // 只能在某个外部可变容器中替换引用,但这不是属性的职责
        println("Warning: Cannot mutate immutable String")
    }

// 开销较大的计算属性
val String.isPalindrome: Boolean
    get() = this == this.reversed() // 每次访问都会创建反转字符串
 
fun inefficientUsage(text: String) {
    // 糟糕的写法:在循环中多次访问计算属性
    repeat(1000) {
        if (text.isPalindrome) { // 每次循环都重新计算
            println("Is palindrome")
        }
    }
}
 
fun efficientUsage(text: String) {
    // 优化写法:缓存计算结果
    val isPalindrome = text.isPalindrome // 只计算一次
    repeat(1000) {
        if (isPalindrome) { // 使用缓存的值
            println("Is palindrome")
        }
    }
}

// 轻量级计算:适合作为属性
val List<Int>.sum: Int
    get() = this.sum() // O(n) 但常用,可接受
 
// 重量级计算:最好作为函数,明确表达有计算成本
fun <T> List<T>.allPermutations(): List<List<T>> {
    // 复杂的排列组合算法
    // 使用函数而非属性,提醒调用者这是一个昂贵的操作
    // ...
}

// File: StringExtensions.kt
package com.example.utils
 
/**
 * 顶层扩展函数: 判断字符串是否为空或仅包含空白字符
 * 接收者类型: String
 * 返回值: Boolean
 */
fun String.isBlankOrEmpty(): Boolean {
    // trim() 移除首尾空白字符
    // isEmpty() 检查结果是否为空字符串
    return this.trim().isEmpty()
}
 
/**
 * 顶层扩展属性: 计算字符串中的单词数量
 * 注意: 扩展属性不能有幕后字段,必须通过 get() 计算
 */
val String.wordCount: Int
    get() {
        // 如果字符串为空白,返回 0
        if (this.isBlank()) return 0
        // split("\\s+") 按空白字符分割,转为正则表达式
        // toRegex() 将字符串转换为正则表达式对象
        return this.split("\\s+".toRegex()).size
    }
 
// File: Main.kt
package com.example
 
// 导入顶层扩展 (如果在不同包中)
import com.example.utils.isBlankOrEmpty
import com.example.utils.wordCount
 
fun main() {
    val text = "   Hello Kotlin World   "
    
    // 调用顶层扩展函数,语法如同调用成员方法
    println(text.isBlankOrEmpty())  // 输出: false
    
    // 访问顶层扩展属性,语法如同访问成员属性
    println(text.wordCount)         // 输出: 3
    
    val emptyText = "    "
    println(emptyText.isBlankOrEmpty())  // 输出: true
    println(emptyText.wordCount)         // 输出: 0
}

/**
 * HTML DSL 示例: 使用成员扩展构建类型安全的 HTML 构建器
 */
class HTMLBuilder {
    // 存储生成的 HTML 标签
    private val elements = mutableListOf<String>()
    
    /**
     * 成员扩展函数: 为 String 添加 unaryPlus 操作符
     * 接收者: String (扩展接收者)
     * 上下文: HTMLBuilder 实例 (分发接收者)
     * 
     * 这个扩展只在 HTMLBuilder 内部可见和可用
     */
    operator fun String.unaryPlus() {
        // this 指向 String 实例 (扩展接收者)
        // this@HTMLBuilder 指向外部 HTMLBuilder 实例 (分发接收者)
        this@HTMLBuilder.elements.add(this)
    }
    
    /**
     * 成员扩展函数: 为 String 添加 invoke 操作符,支持嵌套标签
     * 接收者: String (扩展接收者,表示标签名)
     * 参数: block - 接收者为 HTMLBuilder 的 lambda
     */
    operator fun String.invoke(block: HTMLBuilder.() -> Unit) {
        // this 是标签名 (如 "div")
        this@HTMLBuilder.elements.add("<$this>")
        
        // 创建新的 HTMLBuilder 实例作为嵌套上下文
        val nested = HTMLBuilder()
        // 在嵌套上下文中执行 block
        nested.block()
        
        // 将嵌套内容添加到当前构建器
        this@HTMLBuilder.elements.addAll(nested.elements)
        
        this@HTMLBuilder.elements.add("</$this>")
    }
    
    /**
     * 构建最终的 HTML 字符串
     */
    fun build(): String = elements.joinToString("\n")
}
 
/**
 * DSL 入口函数: 创建 HTML 构建器并执行构建逻辑
 */
fun html(block: HTMLBuilder.() -> Unit): String {
    val builder = HTMLBuilder()
    builder.block()  // 执行构建逻辑
    return builder.build()
}
 
// 使用示例
fun main() {
    val htmlContent = html {
        // 在这个作用域内,"div"、"p" 等字符串拥有了特殊的语义
        // 因为 HTMLBuilder 的成员扩展为它们添加了 invoke 操作符
        
        "div" {  // 调用 String.invoke(block)
            +"<h1>Welcome</h1>"  // 调用 String.unaryPlus()
            
            "p" {
                +"This is a paragraph"
            }
            
            "p" {
                +"Another paragraph"
            }
        }
    }
    
    println(htmlContent)
    /*
     * 输出:
     * <div>
     * <h1>Welcome</h1>
     * <p>
     * This is a paragraph
     * </p>
     * <p>
     * Another paragraph
     * </p>
     * </div>
     */
}

// Kotlin 源码
class Container {
    fun String.extend() { /* ... */ }
}
 
// 等价的 Java 字节码概念 (伪代码)
public static void extend(Container $this, String $receiver) {
    // 方法体
}

/**
 * 原始类定义: User 类包含伴生对象
 */
class User(val name: String, val age: Int) {
    companion object {
        // 伴生对象可以包含常量或工厂方法
        const val MIN_AGE = 0
        const val MAX_AGE = 150
    }
}
 
/**
 * 为 User 的伴生对象添加扩展函数
 * 接收者: User.Companion (伴生对象类型)
 * 
 * 注意: 必须显式声明接收者类型为 User.Companion
 */
fun User.Companion.createGuest(): User {
    // 在扩展函数内部,可以访问伴生对象的成员
    // this 指向 User.Companion 单例
    return User("Guest", 18)
}
 
/**
 * 为伴生对象添加工厂方法: 从 JSON 字符串创建 User
 */
fun User.Companion.fromJson(json: String): User? {
    // 简化的 JSON 解析逻辑 (实际应使用 kotlinx.serialization)
    val regex = """"name":"([^"]+)".*"age":(\d+)""".toRegex()
    val match = regex.find(json) ?: return null
    
    val (name, ageStr) = match.destructured  // 解构匹配结果
    val age = ageStr.toIntOrNull() ?: return null
    
    // 验证年龄范围 (访问伴生对象的常量)
    if (age !in MIN_AGE..MAX_AGE) return null
    
    return User(name, age)
}
 
/**
 * 为伴生对象添加扩展属性: 提供默认实例
 */
val User.Companion.default: User
    get() = User("Anonymous", 0)
 
// 使用示例
fun main() {
    // 调用伴生对象扩展函数,语法如同调用静态方法
    val guest = User.createGuest()
    println("Guest: ${guest.name}, ${guest.age}")  // 输出: Guest: Guest, 18
    
    // 从 JSON 创建用户
    val json = """{"name":"Alice","age":30}"""
    val alice = User.fromJson(json)
    println("From JSON: ${alice?.name}, ${alice?.age}")  // 输出: From JSON: Alice, 30
    
    // 访问扩展属性
    val defaultUser = User.default
    println("Default: ${defaultUser.name}, ${defaultUser.age}")  // 输出: Default: Anonymous, 0
    
    // 验证边界情况
    val invalidJson = """{"name":"Bob","age":200}"""
    val bob = User.fromJson(invalidJson)
    println("Invalid age: $bob")  // 输出: Invalid age: null
}

open class Base {
    companion object
}
 
class Derived : Base()
 
// 为 Base 的伴生对象添加扩展
fun Base.Companion.extensionMethod() {
    println("Base companion extension")
}
 
fun main() {
    Base.extensionMethod()     // 正确: 输出 "Base companion extension"
    // Derived.extensionMethod()  // 编译错误: Derived 的伴生对象没有此扩展
}

/**
 * 定义类层次结构
 */
open class Shape {
    open fun draw() {
        println("Drawing a shape")  // 虚方法,支持多态
    }
}
 
class Circle : Shape() {
    override fun draw() {
        println("Drawing a circle")  // 重写父类方法
    }
}
 
/**
 * 为 Shape 添加扩展函数
 */
fun Shape.describe(): String {
    return "This is a shape"  // 扩展函数,静态解析
}
 
/**
 * 为 Circle 添加扩展函数
 */
fun Circle.describe(): String {
    return "This is a circle"  // 另一个独立的扩展函数
}
 
// 测试静态解析行为
fun main() {
    // 声明类型为 Shape,运行时类型为 Circle
    val shape: Shape = Circle()
    
    // 调用成员方法 draw(): 动态分发,调用 Circle.draw()
    shape.draw()  // 输出: "Drawing a circle"
    
    // 调用扩展函数 describe(): 静态解析,调用 Shape.describe()
    println(shape.describe())  // 输出: "This is a shape"
    
    // 如果显式转换为 Circle 类型
    val circle = shape as Circle
    println(circle.describe())  // 输出: "This is a circle"
}

// Kotlin 编译后的等价 Java 伪代码
public static String describe(Shape $this) {
    return "This is a shape";
}
 
public static String describe(Circle $this) {
    return "This is a circle";
}
 
// 调用时
Shape shape = new Circle();
String result = ExtensionsKt.describe(shape);  // 调用 describe(Shape)

/**
 * 定义一个类,包含成员方法 print()
 */
class Document {
    /**
     * 成员方法: 打印文档内容
     */
    fun print() {
        println("Printing document content")
    }
}
 
/**
 * 为 Document 添加同名扩展函数 print()
 * 注意: 这个扩展函数会被成员方法覆盖 (Shadowed)
 */
fun Document.print() {
    println("Extension: Printing document")
}
 
/**
 * 为 Document 添加不同签名的扩展函数 print(String)
 * 这个扩展函数不会被覆盖,因为签名不同
 */
fun Document.print(message: String) {
    println("Extension: $message")
}
 
fun main() {
    val doc = Document()
    
    // 调用 print(): 成员方法优先,输出 "Printing document content"
    doc.print()
    
    // 调用 print(String): 扩展函数,因为成员方法没有这个签名
    doc.print("Custom message")  // 输出: "Extension: Custom message"
}

/**
 * 演示成员优先规则的细节
 */
class Container {
    // 成员方法: 参数类型为 Any?
    fun process(value: Any?) {
        println("Member: processing $value")
    }
}
 
// 扩展函数: 参数类型为 String (更具体)
fun Container.process(value: String) {
    println("Extension: processing string $value")
}
 
fun main() {
    val container = Container()
    
    // 传入 String 类型参数
    container.process("test")  
    // 输出: "Member: processing test"
    // 即使扩展函数的参数类型更匹配,成员方法仍然优先
    
    // 显式调用扩展函数需要使用 run 作用域函数
    with(container) {
        // 在 with 作用域内,扩展函数仍然被成员方法覆盖
        process("test")  // 输出: "Member: processing test"
    }
}