继承与多态基础

// ❌ 编译错误：默认 final，无法继承
class Animal {
    fun eat() { println("eating") }
}
 
class Dog : Animal()  // Error: This type is final, so it cannot be inherited from
 
// ✅ 正确：使用 open 显式允许继承
open class Animal {
    open fun eat() { println("eating") }  // 方法也需要 open 才能被覆盖
}
 
class Dog : Animal()  // 编译通过

// 父类定义
open class Person(val name: String, var age: Int) {
    open fun introduce() {
        println("I'm $name, $age years old")
    }
}
 
// 子类继承 —— 主构造函数形式
class Student(
    name: String,           // 传递给父类，不加 val/var
    age: Int,
    val studentId: String   // 子类新增属性，需要 val/var
) : Person(name, age) {     // 冒号后调用父类构造函数
    
    override fun introduce() {
        println("I'm $name, student ID: $studentId")
    }
}
 
// 使用示例
fun main() {
    val student = Student("Alice", 20, "2024001")
    student.introduce()  // 输出: I'm Alice, student ID: 2024001
}

// 场景1：父类有主构造函数
open class Parent(val x: Int)
class Child(x: Int, val y: Int) : Parent(x)  // 必须在声明处调用
 
// 场景2：父类无主构造函数，有次构造函数
open class Parent {
    val x: Int
    constructor(x: Int) {
        this.x = x
    }
}
class Child : Parent {
    constructor(x: Int) : super(x)  // 使用 super 调用父类次构造函数
}
 
// 场景3：父类有多个构造函数
open class Parent(val x: Int) {
    constructor(x: Int, y: Int) : this(x)
}
class Child : Parent {
    constructor(x: Int) : super(x)           // 调用父类主构造
    constructor(x: Int, y: Int) : super(x, y) // 调用父类次构造
}

open class Base(val name: String) {
    init {
        println("Base init: name = $name")
        printName()  // ⚠️ 危险：此时子类尚未初始化
    }
    
    open fun printName() {
        println("Base.printName: $name")
    }
}
 
class Derived(name: String, val extra: String) : Base(name) {
    init {
        println("Derived init: extra = $extra")
    }
    
    override fun printName() {
        println("Derived.printName: $extra")  // extra 此时为 null！
    }
}
 
fun main() {
    Derived("test", "extraValue")
}

┌─────────────────────────────────────────────────────────────┐
│              对象初始化顺序 (Initialization Order)            │
├─────────────────────────────────────────────────────────────┤
│  1. 父类主构造参数求值                                        │
│         ↓                                                   │
│  2. 父类属性初始化器 + init 块（按声明顺序）                    │
│         ↓                                                   │
│  3. 父类次构造函数体（如有）                                   │
│         ↓                                                   │
│  4. 子类主构造参数求值                                        │
│         ↓                                                   │
│  5. 子类属性初始化器 + init 块（按声明顺序）                    │
│         ↓                                                   │
│  6. 子类次构造函数体（如有）                                   │
└─────────────────────────────────────────────────────────────┘

open class Shape {
    open fun draw() { println("Drawing shape") }
    fun fill() { println("Filling shape") }  // 非 open，不可覆盖
}
 
class Circle : Shape() {
    // ✅ 正确：override 是必须的
    override fun draw() { println("Drawing circle") }
    
    // ❌ 编译错误：缺少 override
    // fun draw() { println("Drawing circle") }
    
    // ❌ 编译错误：fill() 不是 open 的
    // override fun fill() { println("Filling circle") }
}

open class Animal {
    open fun makeSound() { println("Some sound") }
}
 
open class Dog : Animal() {
    // 允许继续被覆盖
    override fun makeSound() { println("Bark!") }
}
 
open class Cat : Animal() {
    // 禁止子类继续覆盖
    final override fun makeSound() { println("Meow!") }
}
 
class Labrador : Dog() {
    // ✅ 可以覆盖，因为 Dog.makeSound() 没有 final
    override fun makeSound() { println("Woof woof!") }
}
 
class PersianCat : Cat() {
    // ❌ 编译错误：Cat.makeSound() 是 final 的
    // override fun makeSound() { println("Purr~") }
}

open class Printer {
    open fun print(message: String) {
        println("Printer: $message")
    }
    
    // 带默认参数的方法覆盖
    open fun printWithPrefix(message: String, prefix: String = ">>>") {
        println("$prefix $message")
    }
}
 
class ColorPrinter : Printer() {
    override fun print(message: String) {
        println("🎨 ColorPrinter: $message")
    }
    
    // 覆盖时不能改变默认参数值（会被忽略）
    override fun printWithPrefix(message: String, prefix: String) {
        println("🎨 $prefix $message")
    }
}
 
fun main() {
    val printer: Printer = ColorPrinter()  // 多态引用
    printer.print("Hello")                  // 输出: 🎨 ColorPrinter: Hello
    printer.printWithPrefix("World")        // 输出: 🎨 >>> World（使用父类默认值）
}

open class Vehicle {
    open val wheels: Int = 4           // 只读属性
    open var speed: Int = 0            // 可读写属性
    open val maxSpeed: Int get() = 200 // 带 getter 的只读属性
}
 
class Motorcycle : Vehicle() {
    // ✅ val 可以被 val 覆盖
    override val wheels: Int = 2
    
    // ✅ val 可以被 var 覆盖（扩展能力：增加 setter）
    override var maxSpeed: Int = 180
    
    // ❌ var 不能被 val 覆盖（削减能力：移除 setter）
    // override val speed: Int = 0  // 编译错误
    
    // ✅ var 可以被 var 覆盖
    override var speed: Int = 0
}

┌────────────────────────────────────────────────────────┐
│           属性覆盖规则 (Property Override Rules)         │
├────────────────────────────────────────────────────────┤
│                                                        │
│   父类 val  ──────►  子类 val  ✅ (保持只读)             │
│       │                                                │
│       └──────────►  子类 var  ✅ (扩展为可写)            │
│                                                        │
│   父类 var  ──────►  子类 var  ✅ (保持可读写)           │
│       │                                                │
│       └──────────►  子类 val  ❌ (不能削减能力)          │
│                                                        │
└────────────────────────────────────────────────────────┘

open class User(open val name: String, open val email: String)
 
// 在主构造函数中直接覆盖
class AdminUser(
    override val name: String,
    override val email: String,
    val adminLevel: Int
) : User(name, email)
 
// 等价的完整写法
class AdminUserVerbose(name: String, email: String, val adminLevel: Int) : User(name, email) {
    override val name: String = name
    override val email: String = email
}

open class Rectangle(val width: Double, val height: Double) {
    open val area: Double
        get() = width * height
    
    open var borderColor: String = "black"
        protected set  // 限制 setter 可见性
}
 
class Square(side: Double) : Rectangle(side, side) {
    // 覆盖 getter，添加日志
    override val area: Double
        get() {
            println("Calculating square area...")
            return super.width * super.width  // 或 width * height
        }
    
    // 覆盖并改变 setter 行为
    override var borderColor: String = "blue"
        set(value) {
            println("Square border color changing to: $value")
            field = value.uppercase()  // 自定义逻辑
        }
}
 
fun main() {
    val square = Square(5.0)
    println(square.area)           // 输出: Calculating square area... \n 25.0
    square.borderColor = "red"     // 输出: Square border color changing to: red
    println(square.borderColor)    // 输出: RED
}

open class Temperature {
    open var celsius: Double = 0.0
    
    // 计算属性：没有 backing field
    open val fahrenheit: Double
        get() = celsius * 9 / 5 + 32
}
 
class SmartThermometer : Temperature() {
    private var _lastUpdated: Long = 0
    
    // 覆盖并添加副作用
    override var celsius: Double = 0.0
        set(value) {
            field = value                          // 使用 backing field
            _lastUpdated = System.currentTimeMillis()
            println("Temperature updated at $_lastUpdated")
        }
    
    // 覆盖计算属性，改变计算逻辑（四舍五入）
    override val fahrenheit: Double
        get() = kotlin.math.round(super.fahrenheit * 10) / 10
}

abstract class DataSource {
    // 抽象属性：没有初始值，没有访问器实现
    abstract val connectionString: String
    abstract var timeout: Int
}
 
class MySqlDataSource : DataSource() {
    // 必须覆盖所有抽象属性
    override val connectionString: String = "jdbc:mysql://localhost:3306/db"
    
    override var timeout: Int = 30000
        set(value) {
            require(value > 0) { "Timeout must be positive" }
            field = value
        }
}
 
class InMemoryDataSource : DataSource() {
    // 可以用计算属性实现抽象属性
    override val connectionString: String
        get() = "memory://temp-${System.nanoTime()}"
    
    override var timeout: Int = 0  // 内存数据源不需要超时
}

open class A {
    open val x: Int = 1
    init { println(x) }
}
 
class B : A() {
    override val x: Int = 2
}
 
fun main() {
    B()
}

open class Parent {
    open val a: Int = 1
    open var b: Int = 2
    open val c: Int get() = 3
}
 
class Child : Parent() {
    override var a: Int = 10      // 选项 A
    override val b: Int = 20      // 选项 B
    override var c: Int = 30      // 选项 C
}

open class Animal {
    open val name: String = "Animal"
    
    open fun makeSound() {
        println("Some generic animal sound")
    }
    
    open fun describe() {
        println("I am an animal named $name")
    }
}
 
class Dog : Animal() {
    override val name: String = "Dog"
    
    override fun makeSound() {
        // 先调用父类实现，再添加自己的逻辑
        super.makeSound()
        println("Woof! Woof!")
    }
    
    override fun describe() {
        // 完全使用自己的实现，但访问父类属性
        println("I am a dog. Parent says my name is: ${super.name}")
        println("But I know my name is: $name")
    }
}
 
fun main() {
    val dog = Dog()
    dog.makeSound()
    // 输出:
    // Some generic animal sound
    // Woof! Woof!
    
    println("---")
    dog.describe()
    // 输出:
    // I am a dog. Parent says my name is: Animal
    // But I know my name is: Dog
}

open class Person(val name: String, val age: Int) {
    // 父类的次构造函数
    constructor(name: String) : this(name, 0)
}
 
class Employee : Person {
    val employeeId: String
    
    // 次构造函数必须调用父类构造函数
    constructor(name: String, age: Int, id: String) : super(name, age) {
        this.employeeId = id
    }
    
    // 可以调用父类的不同构造函数
    constructor(name: String, id: String) : super(name) {
        this.employeeId = id
    }
    
    // 也可以委托给自己的其他构造函数
    constructor(id: String) : this("Unknown", 0, id)
}

open class Rectangle {
    open fun draw() {
        println("Drawing a rectangle")
    }
    
    open val borderColor: String = "black"
}
 
interface Clickable {
    // 接口方法的默认实现
    fun draw() {
        println("Clickable: highlighting")
    }
    
    val borderColor: String
        get() = "blue"
}
 
interface Focusable {
    fun draw() {
        println("Focusable: drawing focus indicator")
    }
}
 
// 同时继承类和实现多个接口
class Button : Rectangle(), Clickable, Focusable {
    
    // 必须覆盖 draw()，因为存在多个实现
    override fun draw() {
        // 使用限定 super 分别调用不同父类型的实现
        super<Rectangle>.draw()      // 调用 Rectangle 的 draw
        super<Clickable>.draw()      // 调用 Clickable 的 draw
        super<Focusable>.draw()      // 调用 Focusable 的 draw
        println("Button: final rendering")
    }
    
    // 属性同样可以使用限定 super
    override val borderColor: String
        get() = "Rectangle says: ${super<Rectangle>.borderColor}, " +
                "Clickable says: ${super<Clickable>.borderColor}"
}
 
fun main() {
    val button = Button()
    button.draw()
    // 输出:
    // Drawing a rectangle
    // Clickable: highlighting
    // Focusable: drawing focus indicator
    // Button: final rendering
    
    println(button.borderColor)
    // 输出: Rectangle says: black, Clickable says: blue
}

open class Base {
    open fun printMessage() {
        println("Base message")
    }
}
 
class Outer : Base() {
    override fun printMessage() {
        println("Outer message")
    }
    
    inner class Inner {
        fun callOuterSuper() {
            // 访问外部类 Outer 的父类 Base 的方法
            super@Outer.printMessage()  // 输出: Base message
            
            // 对比：访问外部类自己的方法
            this@Outer.printMessage()   // 输出: Outer message
        }
    }
}
 
fun main() {
    val outer = Outer()
    val inner = outer.Inner()
    inner.callOuterSuper()
}

// 抽象类：不能直接实例化
abstract class Shape {
    // 抽象属性：没有初始值，子类必须覆盖
    abstract val name: String
    abstract val area: Double
    
    // 抽象方法：没有方法体，子类必须实现
    abstract fun draw()
    
    // 普通方法：有默认实现，子类可选择覆盖
    open fun describe() {
        println("This is a $name with area $area")
    }
    
    // 非 open 方法：子类不能覆盖
    fun printClassName() {
        println("Class: ${this::class.simpleName}")
    }
}
 
// ❌ 编译错误：抽象类不能实例化
// val shape = Shape()
 
// ✅ 正确：通过子类实例化
class Circle(val radius: Double) : Shape() {
    override val name: String = "Circle"
    override val area: Double
        get() = Math.PI * radius * radius
    
    override fun draw() {
        println("Drawing a circle with radius $radius")
    }
}
 
class Rectangle(val width: Double, val height: Double) : Shape() {
    override val name: String = "Rectangle"
    override val area: Double = width * height
    
    override fun draw() {
        println("Drawing a rectangle ${width}x${height}")
    }
    
    // 可选：覆盖非抽象的 open 方法
    override fun describe() {
        println("Rectangle: $width x $height = $area")
    }
}

abstract class DataProcessor {
    // 模板方法：定义处理流程的骨架
    fun process() {
        val data = readData()           // 步骤1：读取数据（抽象）
        val validated = validate(data)   // 步骤2：验证（抽象）
        if (validated) {
            val result = transform(data) // 步骤3：转换（抽象）
            save(result)                 // 步骤4：保存（有默认实现）
        }
        cleanup()                        // 步骤5：清理（有默认实现）
    }
    
    // 抽象方法：子类必须实现
    abstract fun readData(): String
    abstract fun validate(data: String): Boolean
    abstract fun transform(data: String): String
    
    // 可覆盖的方法：有默认实现
    open fun save(result: String) {
        println("Saving: $result")
    }
    
    // 不可覆盖的方法
    private fun cleanup() {
        println("Cleanup completed")
    }
}
 
class CsvProcessor(private val filePath: String) : DataProcessor() {
    override fun readData(): String {
        println("Reading CSV from $filePath")
        return "csv,data,here"
    }
    
    override fun validate(data: String): Boolean {
        return data.contains(",")
    }
    
    override fun transform(data: String): String {
        return data.split(",").joinToString("|")
    }
}
 
class JsonProcessor(private val url: String) : DataProcessor() {
    override fun readData(): String {
        println("Fetching JSON from $url")
        return """{"key": "value"}"""
    }
    
    override fun validate(data: String): Boolean {
        return data.startsWith("{") && data.endsWith("}")
    }
    
    override fun transform(data: String): String {
        return data.replace("\"", "'")
    }
    
    // 覆盖默认的 save 实现
    override fun save(result: String) {
        println("Saving to database: $result")
    }
}

┌─────────────────────────────────────────────────────────────────┐
│              抽象类 vs 接口 (Abstract Class vs Interface)         │
├────────────────────────┬────────────────────────────────────────┤
│       抽象类            │              接口                       │
├────────────────────────┼────────────────────────────────────────┤
│ 可以有构造函数           │ 不能有构造函数                          │
│ 可以有状态（属性+backing │ 属性不能有 backing field               │
│   field）              │ （只能是抽象的或提供访问器）               │
│ 单继承                  │ 多实现                                  │
│ 可以有 private 成员     │ 成员默认 public，不能 private           │
│ 表达 "is-a" 关系        │ 表达 "can-do" 能力                      │
└────────────────────────┴────────────────────────────────────────┘

// 基本接口声明
interface Drawable {
    // 抽象方法：实现类必须提供实现
    fun draw()
    
    // 带默认实现的方法
    fun prepare() {
        println("Preparing to draw...")
    }
}
 
// 实现接口
class Circle : Drawable {
    override fun draw() {
        println("Drawing a circle")
    }
    // prepare() 可以不覆盖，使用默认实现
}
 
// 同时继承类和实现接口
open class Shape
class Square : Shape(), Drawable {
    override fun draw() {
        println("Drawing a square")
    }
}

interface Logger {
    // 抽象属性
    val tag: String
    
    // 抽象方法
    fun log(message: String)
    
    // 带默认实现的方法
    fun debug(message: String) {
        log("DEBUG [$tag]: $message")
    }
    
    fun info(message: String) {
        log("INFO [$tag]: $message")
    }
    
    fun error(message: String, throwable: Throwable? = null) {
        log("ERROR [$tag]: $message")
        throwable?.let { log("  Caused by: ${it.message}") }
    }
    
    // 默认实现可以调用其他成员（包括抽象成员）
    fun logSeparator() {
        log("=".repeat(50))
    }
}
 
class ConsoleLogger(override val tag: String) : Logger {
    // 只需实现抽象方法
    override fun log(message: String) {
        println(message)
    }
}
 
class FileLogger(
    override val tag: String,
    private val filePath: String
) : Logger {
    override fun log(message: String) {
        // 实际项目中会写入文件
        println("[FILE:$filePath] $message")
    }
    
    // 可选：覆盖默认实现
    override fun error(message: String, throwable: Throwable?) {
        log("🔴 CRITICAL ERROR [$tag]: $message")
        throwable?.printStackTrace()
    }
}
 
fun main() {
    val console = ConsoleLogger("App")
    console.debug("Application started")  // 使用默认实现
    console.info("Processing...")
    console.logSeparator()
    
    val file = FileLogger("App", "/var/log/app.log")
    file.error("Something went wrong", RuntimeException("Test"))  // 使用覆盖的实现
}

interface Vehicle {
    // 抽象属性：实现类必须提供
    val wheels: Int
    val brand: String
    
    // 带 getter 的属性：提供默认实现
    val description: String
        get() = "$brand vehicle with $wheels wheels"
    
    // 可变属性也可以声明（但不能有初始值）
    var currentSpeed: Int
    
    // ❌ 错误：接口属性不能有初始值（需要 backing field）
    // val maxSpeed: Int = 200
    
    // ✅ 正确：通过 getter 提供"默认值"
    val maxSpeed: Int
        get() = 200
}
 
class Car(
    override val brand: String,
    override var currentSpeed: Int = 0
) : Vehicle {
    override val wheels: Int = 4
    
    // 可以覆盖有默认 getter 的属性
    override val maxSpeed: Int
        get() = 250
}
 
class Motorcycle(override val brand: String) : Vehicle {
    override val wheels: Int = 2
    override var currentSpeed: Int = 0
    
    // 使用默认的 description 和 maxSpeed
}
 
fun main() {
    val car = Car("Toyota")
    println(car.description)  // Toyota vehicle with 4 wheels
    println(car.maxSpeed)     // 250
    
    val bike = Motorcycle("Honda")
    println(bike.description) // Honda vehicle with 2 wheels
    println(bike.maxSpeed)    // 200 (默认值)
}

interface Example {
    // 形式1：抽象属性（必须被覆盖）
    val abstractProp: String
    
    // 形式2：带默认 getter 的属性（可选覆盖）
    val computedProp: String
        get() = "computed value"
    
    // 形式3：抽象可变属性
    var mutableProp: Int
}

interface Named {
    val name: String
}
 
interface Aged {
    val age: Int
}
 
// 接口继承多个接口
interface Person : Named, Aged {
    val email: String
    
    fun introduce() {
        println("I'm $name, $age years old. Email: $email")
    }
}
 
// 实现组合接口
class Employee(
    override val name: String,
    override val age: Int,
    override val email: String,
    val department: String
) : Person
 
// 接口可以覆盖继承的成员
interface Student : Person {
    val studentId: String
    
    // 覆盖父接口的默认实现
    override fun introduce() {
        println("Student $name (ID: $studentId), $age years old")
    }
}

// 使用 fun interface 声明函数式接口
fun interface Transformer<T, R> {
    fun transform(input: T): R
    
    // 可以有非抽象成员
    fun andThen(next: Transformer<R, R>): Transformer<T, R> {
        return Transformer { input -> next.transform(this.transform(input)) }
    }
}
 
fun interface Predicate<T> {
    fun test(value: T): Boolean
}
 
fun main() {
    // 使用 Lambda 创建实例（SAM 转换）
    val stringLength: Transformer<String, Int> = Transformer { it.length }
    val doubler: Transformer<Int, Int> = Transformer { it * 2 }
    
    println(stringLength.transform("Hello"))  // 5
    
    // 链式调用
    val combined = stringLength.andThen(doubler)
    println(combined.transform("Hello"))  // 10
    
    // Predicate 示例
    val isLong: Predicate<String> = Predicate { it.length > 5 }
    println(isLong.test("Kotlin"))  // true
    println(isLong.test("Java"))    // false
    
    // 作为高阶函数参数
    val words = listOf("apple", "banana", "cherry", "date")
    val longWords = words.filter { isLong.test(it) }
    println(longWords)  // [banana, cherry]
}

open class A {
    open fun greet() = "Hello from A"
}
 
interface B {
    fun greet() = "Hello from B"
}
 
class C : A(), B {
    override fun greet(): String {
        return "${super<A>.greet()} and ${super<B>.greet()}"
    }
}
 
fun main() {
    println(C().greet())
}

interface Config {
    val a: String = "default"           // 选项 A
    val b: String get() = "default"     // 选项 B
    var c: String = "default"           // 选项 C
    var d: String                       // 选项 D
}

// 定义多个独立的接口，每个代表一种能力
interface Flyable {
    val maxAltitude: Int
    fun fly()
    fun land() {
        println("Landing safely")
    }
}
 
interface Swimmable {
    val maxDepth: Int
    fun swim()
    fun surface() {
        println("Surfacing")
    }
}
 
interface Walkable {
    fun walk()
    fun run() {
        println("Running on ground")
    }
}
 
// 鸭子：能飞、能游、能走
class Duck(
    override val maxAltitude: Int = 1000,
    override val maxDepth: Int = 5
) : Flyable, Swimmable, Walkable {
    
    override fun fly() {
        println("Duck flying up to $maxAltitude meters")
    }
    
    override fun swim() {
        println("Duck swimming at depth $maxDepth meters")
    }
    
    override fun walk() {
        println("Duck waddling")
    }
}
 
// 企鹅：能游、能走，但不能飞
class Penguin(override val maxDepth: Int = 500) : Swimmable, Walkable {
    
    override fun swim() {
        println("Penguin diving to $maxDepth meters")
    }
    
    override fun walk() {
        println("Penguin waddling on ice")
    }
}
 
fun main() {
    val duck = Duck()
    duck.fly()      // Duck flying up to 1000 meters
    duck.swim()     // Duck swimming at depth 5 meters
    duck.walk()     // Duck waddling
    duck.land()     // Landing safely (默认实现)
    
    // 多态：通过接口类型引用
    val swimmers: List<Swimmable> = listOf(Duck(), Penguin())
    swimmers.forEach { it.swim() }
}

interface A {
    fun display() {
        println("Display from A")
    }
    
    fun process(): String = "A"
    
    val name: String
        get() = "Interface A"
}
 
interface B {
    fun display() {
        println("Display from B")
    }
    
    fun process(): String = "B"
    
    val name: String
        get() = "Interface B"
}
 
// 实现两个有冲突成员的接口
class MyClass : A, B {
    
    // 必须覆盖冲突的方法
    override fun display() {
        // 可以选择调用其中一个
        super<A>.display()
        // 或者两个都调用
        super<B>.display()
        // 或者完全自定义
        println("Display from MyClass")
    }
    
    // 必须覆盖冲突的方法
    override fun process(): String {
        // 组合两个接口的结果
        return "${super<A>.process()} + ${super<B>.process()}"
    }
    
    // 必须覆盖冲突的属性
    override val name: String
        get() = "MyClass (from A: ${super<A>.name}, from B: ${super<B>.name})"
}
 
fun main() {
    val obj = MyClass()
    obj.display()
    // 输出:
    // Display from A
    // Display from B
    // Display from MyClass
    
    println(obj.process())  // A + B
    println(obj.name)       // MyClass (from A: Interface A, from B: Interface B)
}

interface Printer {
    fun print(message: String) {
        println("[Printer] $message")
    }
    
    fun getStatus(): String = "Printer OK"
}
 
interface Scanner {
    fun print(message: String) {  // 同名方法
        println("[Scanner] $message")
    }
    
    fun getStatus(): String = "Scanner OK"  // 同名方法
    
    fun scan(): String = "Scanned document"
}
 
interface Fax {
    fun getStatus(): String = "Fax OK"  // 又一个同名方法
    
    fun sendFax(document: String) {
        println("Sending fax: $document")
    }
}
 
// 多功能一体机
class MultiFunctionDevice : Printer, Scanner, Fax {
    
    // 三个接口都有 getStatus()，必须覆盖
    override fun getStatus(): String {
        // 使用 super<T> 分别调用
        val printerStatus = super<Printer>.getStatus()
        val scannerStatus = super<Scanner>.getStatus()
        val faxStatus = super<Fax>.getStatus()
        return "Device Status: $printerStatus, $scannerStatus, $faxStatus"
    }
    
    // Printer 和 Scanner 都有 print()，必须覆盖
    override fun print(message: String) {
        println("=== MultiFunctionDevice Print ===")
        super<Printer>.print(message)  // 调用 Printer 的实现
        // 注意：这里选择不调用 Scanner.print()
    }
    
    // scan() 只在 Scanner 中有，可以直接使用默认实现
    // sendFax() 只在 Fax 中有，可以直接使用默认实现
}
 
fun main() {
    val device = MultiFunctionDevice()
    
    println(device.getStatus())
    // Device Status: Printer OK, Scanner OK, Fax OK
    
    device.print("Hello World")
    // === MultiFunctionDevice Print ===
    // [Printer] Hello World
    
    println(device.scan())  // Scanned document
    device.sendFax("Contract")  // Sending fax: Contract
}

┌──────────────────────────────────────────────────────────────────┐
│           接口冲突规则 (Interface Conflict Rules)                  │
├──────────────────────────────────────────────────────────────────┤
│                                                                  │
│  情况1: 多个接口有同名抽象成员                                      │
│  ────────────────────────────                                    │
│  → 实现类只需提供一个实现（满足所有接口）                             │
│                                                                  │
│  情况2: 多个接口有同名默认实现                                      │
│  ────────────────────────────                                    │
│  → 实现类必须覆盖，否则编译错误                                     │
│  → 可用 super<T> 选择性调用                                       │
│                                                                  │
│  情况3: 一个抽象 + 一个默认实现                                     │
│  ────────────────────────────                                    │
│  → 实现类必须覆盖（抽象成员优先级更高）                              │
│                                                                  │
│  情况4: 类继承 + 接口实现有同名成员                                 │
│  ────────────────────────────                                    │
│  → 类的实现优先（如果类有具体实现）                                  │
│  → 否则必须覆盖                                                   │
│                                                                  │
└──────────────────────────────────────────────────────────────────┘

// 传统方式：手动实现委托（Java 风格）
interface SoundBehavior {
    fun makeSound()
}
 
class BarkSound : SoundBehavior {
    override fun makeSound() {
        println("Woof!")
    }
}
 
// 手动委托：需要写大量样板代码
class DogManual(private val soundBehavior: SoundBehavior) : SoundBehavior {
    override fun makeSound() {
        soundBehavior.makeSound()  // 手动转发
    }
}
 
// Kotlin 方式：使用 by 关键字自动委托
class DogKotlin(soundBehavior: SoundBehavior) : SoundBehavior by soundBehavior
// 编译器自动生成所有接口方法的转发代码！
 
fun main() {
    val bark = BarkSound()
    
    val dogManual = DogManual(bark)
    dogManual.makeSound()  // Woof!
    
    val dogKotlin = DogKotlin(bark)
    dogKotlin.makeSound()  // Woof!
}

interface Repository {
    fun save(data: String)
    fun load(id: Int): String
    fun delete(id: Int)
    fun count(): Int
}
 
// 基础实现
class DatabaseRepository : Repository {
    private val storage = mutableMapOf<Int, String>()
    private var nextId = 1
    
    override fun save(data: String) {
        storage[nextId++] = data
        println("DB: Saved '$data'")
    }
    
    override fun load(id: Int): String {
        return storage[id] ?: throw NoSuchElementException("ID $id not found")
    }
    
    override fun delete(id: Int) {
        storage.remove(id)
        println("DB: Deleted ID $id")
    }
    
    override fun count(): Int = storage.size
}
 
// 使用委托添加日志功能，无需重写所有方法
class LoggingRepository(
    private val delegate: Repository
) : Repository by delegate {
    
    // 只覆盖需要增强的方法
    override fun save(data: String) {
        println("[LOG] Saving data: $data")
        delegate.save(data)  // 调用原始实现
        println("[LOG] Save completed")
    }
    
    override fun delete(id: Int) {
        println("[LOG] Deleting ID: $id")
        delegate.delete(id)
        println("[LOG] Delete completed")
    }
    
    // load() 和 count() 自动委托，无需手写
}
 
// 使用委托添加缓存功能
class CachingRepository(
    private val delegate: Repository
) : Repository by delegate {
    
    private val cache = mutableMapOf<Int, String>()
    
    override fun load(id: Int): String {
        return cache.getOrPut(id) {
            println("[CACHE] Cache miss for ID $id, loading from delegate")
            delegate.load(id)
        }.also {
            println("[CACHE] Returning: $it")
        }
    }
    
    override fun save(data: String) {
        delegate.save(data)
        // 注意：这里简化处理，实际需要获取新 ID
    }
}
 
fun main() {
    val db = DatabaseRepository()
    val loggingRepo = LoggingRepository(db)
    val cachingRepo = CachingRepository(loggingRepo)  // 装饰器链
    
    cachingRepo.save("Hello")
    cachingRepo.save("World")
    
    println("Count: ${cachingRepo.count()}")  // 自动委托
    
    println(cachingRepo.load(1))  // 第一次：缓存未命中
    println(cachingRepo.load(1))  // 第二次：缓存命中
}

// Kotlin 源码
interface Greeter {
    fun greet(): String
    fun farewell(): String
}
 
class EnglishGreeter : Greeter {
    override fun greet() = "Hello"
    override fun farewell() = "Goodbye"
}
 
class PoliteGreeter(greeter: Greeter) : Greeter by greeter
 
// 编译器生成的等效 Java 代码（简化版）

// 反编译后的 Java 代码
public final class PoliteGreeter implements Greeter {
    private final Greeter $$delegate_0;  // 委托对象引用
    
    public PoliteGreeter(Greeter greeter) {
        this.$$delegate_0 = greeter;
    }
    
    // 自动生成的转发方法
    @Override
    public String greet() {
        return this.$$delegate_0.greet();
    }
    
    @Override
    public String farewell() {
        return this.$$delegate_0.farewell();
    }
}

// 属性委托的基本形式
class Example {
    // 将 property 的 get/set 委托给 Delegate 对象
    var property: String by Delegate()
}
 
class Delegate {
    private var value: String = "initial"
    
    // 对应属性的 getter
    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        println("Getting '${property.name}' from $thisRef")
        return value
    }
    
    // 对应属性的 setter（var 属性需要）
    operator fun setValue(thisRef: Any?, property: KProperty<*>, newValue: String) {
        println("Setting '${property.name}' to '$newValue' in $thisRef")
        value = newValue
    }
}

class DatabaseConnection {
    init {
        println("DatabaseConnection created - expensive operation!")
        Thread.sleep(1000)  // 模拟耗时操作
    }
    
    fun query(sql: String) = "Result for: $sql"
}
 
class UserService {
    // lazy 委托：只在第一次访问时创建
    val database: DatabaseConnection by lazy {
        println("Initializing database connection...")
        DatabaseConnection()
    }
    
    // 带配置的 lazy
    val config: Map<String, String> by lazy(LazyThreadSafetyMode.PUBLICATION) {
        println("Loading config...")
        mapOf("env" to "production", "version" to "1.0")
    }
    
    fun doSomething() {
        println("doSomething() called")
        // database 在这里才会被初始化
        println(database.query("SELECT * FROM users"))
    }
}
 
fun main() {
    println("Creating UserService...")
    val service = UserService()
    println("UserService created")
    
    println("\n--- First call ---")
    service.doSomething()
    
    println("\n--- Second call ---")
    service.doSomething()  // database 不会重新创建
}

// 不同模式的使用
val syncLazy: String by lazy(LazyThreadSafetyMode.SYNCHRONIZED) { "sync" }
val pubLazy: String by lazy(LazyThreadSafetyMode.PUBLICATION) { "pub" }
val noneLazy: String by lazy(LazyThreadSafetyMode.NONE) { "none" }

import kotlin.properties.Delegates
 
class User {
    // observable：每次赋值后触发回调
    var name: String by Delegates.observable("Unknown") { property, oldValue, newValue ->
        println("${property.name} changed: '$oldValue' -> '$newValue'")
    }
    
    var age: Int by Delegates.observable(0) { prop, old, new ->
        println("Age updated from $old to $new")
        // 可以在这里触发 UI 更新、发送事件等
    }
}
 
// 实际应用：ViewModel 中的状态管理
class LoginViewModel {
    var isLoading: Boolean by Delegates.observable(false) { _, _, isLoading ->
        if (isLoading) {
            println("Showing loading spinner...")
        } else {
            println("Hiding loading spinner...")
        }
    }
    
    var errorMessage: String? by Delegates.observable(null) { _, _, error ->
        error?.let { println("Showing error: $it") }
    }
    
    fun login(username: String, password: String) {
        isLoading = true
        // 模拟网络请求
        Thread.sleep(500)
        if (username == "admin") {
            isLoading = false
            println("Login successful!")
        } else {
            isLoading = false
            errorMessage = "Invalid credentials"
        }
    }
}
 
fun main() {
    val user = User()
    user.name = "Alice"   // name changed: 'Unknown' -> 'Alice'
    user.name = "Bob"     // name changed: 'Alice' -> 'Bob'
    user.age = 25         // Age updated from 0 to 25
    
    println("\n--- LoginViewModel ---")
    val viewModel = LoginViewModel()
    viewModel.login("guest", "123")
}

import kotlin.properties.Delegates
 
class BankAccount(initialBalance: Double) {
    // vetoable：返回 false 则拒绝赋值
    var balance: Double by Delegates.vetoable(initialBalance) { _, oldValue, newValue ->
        val allowed = newValue >= 0  // 不允许负数余额
        if (!allowed) {
            println("❌ Rejected: Cannot set negative balance ($newValue)")
        } else {
            println("✅ Balance changed: $oldValue -> $newValue")
        }
        allowed  // 返回 true 接受，false 拒绝
    }
    
    // 年龄必须在合理范围内
    var ownerAge: Int by Delegates.vetoable(18) { _, _, newAge ->
        newAge in 0..150
    }
}
 
class TemperatureController {
    // 温度必须在安全范围内
    var temperature: Double by Delegates.vetoable(20.0) { _, old, new ->
        when {
            new < -40 -> {
                println("⚠️ Temperature too low! Keeping at $old")
                false
            }
            new > 100 -> {
                println("⚠️ Temperature too high! Keeping at $old")
                false
            }
            else -> {
                println("Temperature set to $new°C")
                true
            }
        }
    }
}
 
fun main() {
    val account = BankAccount(1000.0)
    account.balance = 500.0    // ✅ Balance changed: 1000.0 -> 500.0
    account.balance = -100.0   // ❌ Rejected: Cannot set negative balance
    println("Final balance: ${account.balance}")  // 500.0（拒绝后保持原值）
    
    println("\n--- TemperatureController ---")
    val controller = TemperatureController()
    controller.temperature = 25.0   // Temperature set to 25.0°C
    controller.temperature = 150.0  // ⚠️ Temperature too high!
    controller.temperature = -50.0  // ⚠️ Temperature too low!
    println("Current temp: ${controller.temperature}°C")  // 25.0
}

// 从 Map 读取属性（只读）
class UserFromMap(map: Map<String, Any?>) {
    val name: String by map
    val age: Int by map
    val email: String by map
}
 
// 从 MutableMap 读写属性
class MutableUser(map: MutableMap<String, Any?>) {
    var name: String by map
    var age: Int by map
    var email: String by map
}
 
// 实际应用：解析 JSON 响应
fun parseUserFromJson(json: Map<String, Any?>): UserFromMap {
    return UserFromMap(json)
}
 
// 实际应用：配置管理
class AppConfig(private val configMap: MutableMap<String, Any?>) {
    var appName: String by configMap
    var debugMode: Boolean by configMap
    var maxConnections: Int by configMap
    
    fun toMap(): Map<String, Any?> = configMap.toMap()
}
 
fun main() {
    // 模拟 JSON 数据
    val jsonData = mapOf(
        "name" to "Alice",
        "age" to 28,
        "email" to "alice@example.com"
    )
    
    val user = UserFromMap(jsonData)
    println("Name: ${user.name}")   // Alice
    println("Age: ${user.age}")     // 28
    println("Email: ${user.email}") // alice@example.com
    
    // 可变 Map 委托
    val mutableData = mutableMapOf<String, Any?>(
        "name" to "Bob",
        "age" to 30,
        "email" to "bob@example.com"
    )
    
    val mutableUser = MutableUser(mutableData)
    println("\nBefore: ${mutableUser.name}")
    mutableUser.name = "Robert"
    println("After: ${mutableUser.name}")
    println("Map updated: ${mutableData["name"]}")  // Robert
    
    // 配置管理示例
    println("\n--- AppConfig ---")
    val config = AppConfig(mutableMapOf(
        "appName" to "MyApp",
        "debugMode" to true,
        "maxConnections" to 100
    ))
    
    println("App: ${config.appName}, Debug: ${config.debugMode}")
    config.debugMode = false
    println("Config map: ${config.toMap()}")
}

interface A {
    fun foo() { println("A") }
}
 
interface B {
    fun foo() { println("B") }
}
 
class C : A, B {
    override fun foo() {
        super<B>.foo()
        super<A>.foo()
    }
}
 
fun main() {
    C().foo()
}

import kotlin.reflect.KProperty
 
// 最基础的自定义委托
class SimpleDelegate {
    private var storedValue: String = "default"
    
    // val 和 var 属性都需要 getValue
    operator fun getValue(
        thisRef: Any?,        // 属性所属对象的引用
        property: KProperty<*> // 属性的元数据（名称、类型等）
    ): String {
        println("Getting '${property.name}' from ${thisRef?.javaClass?.simpleName ?: "null"}")
        return storedValue
    }
    
    // 只有 var 属性需要 setValue
    operator fun setValue(
        thisRef: Any?,
        property: KProperty<*>,
        value: String          // 新值
    ) {
        println("Setting '${property.name}' to '$value'")
        storedValue = value
    }
}
 
class Example {
    var text: String by SimpleDelegate()
}
 
fun main() {
    val example = Example()
    println(example.text)      // Getting 'text' from Example → default
    example.text = "Hello"     // Setting 'text' to 'Hello'
    println(example.text)      // Getting 'text' from Example → Hello
}

// 源代码
class Example {
    var text: String by SimpleDelegate()
}
 
// 编译器生成的等效代码（简化）
class Example {
    private val text$delegate = SimpleDelegate()
    
    var text: String
        get() = text$delegate.getValue(this, ::text)
        set(value) = text$delegate.setValue(this, ::text, value)
}

import kotlin.properties.ReadOnlyProperty
import kotlin.reflect.KProperty
 
// 实现 ReadOnlyProperty 接口
class CachedProperty<T>(
    private val initializer: () -> T
) : ReadOnlyProperty<Any?, T> {
    
    private var cachedValue: T? = null
    private var isInitialized = false
    
    override fun getValue(thisRef: Any?, property: KProperty<*>): T {
        if (!isInitialized) {
            println("Initializing '${property.name}'...")
            cachedValue = initializer()
            isInitialized = true
        }
        @Suppress("UNCHECKED_CAST")
        return cachedValue as T
    }
}
 
// 便捷函数，类似标准库的 lazy
fun <T> cached(initializer: () -> T): ReadOnlyProperty<Any?, T> {
    return CachedProperty(initializer)
}
 
// 实际应用：带日志的只读属性
class LoggedReadOnlyProperty<T>(
    private val value: T,
    private val logger: (String) -> Unit = ::println
) : ReadOnlyProperty<Any?, T> {
    
    private var accessCount = 0
    
    override fun getValue(thisRef: Any?, property: KProperty<*>): T {
        accessCount++
        logger("Property '${property.name}' accessed $accessCount time(s)")
        return value
    }
}
 
class Configuration {
    // 使用自定义的 cached 委托
    val databaseUrl: String by cached {
        println("Loading database URL from config file...")
        Thread.sleep(100)  // 模拟 IO 操作
        "jdbc:mysql://localhost:3306/mydb"
    }
    
    // 使用带日志的只读属性
    val appVersion: String by LoggedReadOnlyProperty("1.0.0")
}
 
fun main() {
    val config = Configuration()
    
    // 第一次访问触发初始化
    println("URL: ${config.databaseUrl}")
    // 第二次访问使用缓存
    println("URL: ${config.databaseUrl}")
    
    println("\n--- App Version ---")
    repeat(3) { println("Version: ${config.appVersion}") }
}