编辑“︁Kotlin继承”︁

== Kotlin继承 ==

'''继承'''是面向对象编程（OOP）的核心概念之一，它允许一个类（称为子类或派生类）基于另一个类（称为父类或基类）来构建。Kotlin通过继承机制实现代码复用和层次化设计。本章将详细介绍Kotlin中继承的语法、规则及实际应用。

=== 基本概念 ===
在Kotlin中，所有类默认是<code>final</code>的，即不可被继承。若要使一个类可继承，必须用<code>open</code>关键字显式标记。继承通过<code>:</code>符号实现。

<syntaxhighlight lang="kotlin">
open class Animal(val name: String) {  // 基类标记为open
    open fun makeSound() {            // 方法也需标记为open才能被重写
        println("Some generic animal sound")
    }
}

class Dog(name: String) : Animal(name) {  // 继承语法
    override fun makeSound() {            // 方法重写
        println("$name says: Woof!")
    }
}
</syntaxhighlight>

输出示例：
<pre>
val dog = Dog("Buddy")
dog.makeSound()  // 输出: Buddy says: Woof!
</pre>

=== 继承规则详解 ===

==== 1. 构造函数处理 ====
Kotlin处理构造函数继承的两种方式：
* '''主构造函数'''：子类主构造函数直接初始化父类
* '''次构造函数'''：通过<code>super</code>关键字调用父类构造函数

<syntaxhighlight lang="kotlin">
open class Person(val name: String) {
    // 基类
}

// 方式1：主构造函数继承
class Student(name: String, val id: Int) : Person(name)

// 方式2：次构造函数继承
class Teacher : Person {
    val subject: String
    constructor(name: String, subject: String) : super(name) {
        this.subject = subject
    }
}
</syntaxhighlight>

==== 2. 方法重写 ====
方法重写需遵循：
* 父类方法必须标记为<code>open</code>
* 子类方法必须使用<code>override</code>
* 重写方法本身也是<code>open</code>的（可被进一步重写），除非标记为<code>final</code>

<syntaxhighlight lang="kotlin">
open class Shape {
    open fun draw() { println("Drawing a shape") }
    fun fill() { println("Filling the shape") }  // 不可被重写
}

class Circle : Shape() {
    override fun draw() { println("Drawing a circle") }
}
</syntaxhighlight>

==== 3. 属性重写 ====
属性重写与方法类似，但需类型兼容：

<syntaxhighlight lang="kotlin">
open class Vehicle {
    open val speedLimit: Int = 100
}

class SportsCar : Vehicle() {
    override val speedLimit: Int = 200
}
</syntaxhighlight>

=== 继承层次关系 ===
使用mermaid展示类继承关系：
<mermaid>
classDiagram
    Animal <|-- Dog
    Animal <|-- Cat
    Shape <|-- Circle
    Shape <|-- Rectangle
    Vehicle <|-- Car
    Vehicle <|-- Truck
</mermaid>

=== 实际应用案例 ===
'''场景：'''构建图形编辑器中的UI组件系统

<syntaxhighlight lang="kotlin">
open class UIComponent(val position: Pair<Int, Int>) {
    open fun render() { println("Rendering at $position") }
}

class Button(position: Pair<Int, Int>, val text: String) : UIComponent(position) {
    override fun render() {
        super.render()  // 调用父类实现
        println("Button with text: '$text'")
    }
}

class Image(position: Pair<Int, Int>, val src: String) : UIComponent(position) {
    override fun render() {
        println("Displaying image from $src at $position")
    }
}
</syntaxhighlight>

使用示例：
<pre>
val components = listOf(
    Button((10, 20), "Click me"),
    Image((30, 40), "photo.jpg")
)

components.forEach { it.render() }
</pre>

输出：
<pre>
Rendering at (10, 20)
Button with text: 'Click me'
Displaying image from photo.jpg at (30, 40)
</pre>

=== 高级特性 ===

==== 1. 抽象类 ====
抽象类强制子类实现特定成员：
<syntaxhighlight lang="kotlin">
abstract class DatabaseConnection {
    abstract fun connect()
    fun close() { println("Connection closed") }
}

class MySQLConnection : DatabaseConnection() {
    override fun connect() { println("MySQL connected") }
}
</syntaxhighlight>

==== 2. 接口实现 ====
Kotlin支持多接口继承：
<syntaxhighlight lang="kotlin">
interface Clickable {
    fun onClick()
}

interface Draggable {
    fun onDrag()
}

class UIElement : Clickable, Draggable {
    override fun onClick() { println("Element clicked") }
    override fun onDrag() { println("Element dragged") }
}
</syntaxhighlight>

==== 3. 覆盖规则冲突 ====
当继承的多个接口有相同成员时，需显式解决：
<syntaxhighlight lang="kotlin">
interface A { fun foo() { println("A") } }
interface B { fun foo() { println("B") } }

class C : A, B {
    override fun foo() {
        super<A>.foo()  // 显式选择调用A的实现
        super<B>.foo()  // 显式选择调用B的实现
    }
}
</syntaxhighlight>

=== 数学表示 ===
继承关系可表示为集合包含关系：
<math>
\text{Child} \subset \text{Parent}
</math>

方法重写的数学描述：
<math>
\forall m \in M_{parent}, \exists m' \in M_{child} \mid m' \text{ overrides } m
</math>

=== 最佳实践 ===
1. 优先使用组合而非继承（"favor composition over inheritance"）
2. 保持继承层次扁平（通常不超过3层）
3. 使用<code>final</code>明确禁止不需要的继承
4. 抽象类用于"是什么"关系，接口用于"能做什么"关系

=== 总结 ===
Kotlin的继承系统通过<code>open</code>/<code>override</code>机制提供了明确的继承控制，结合接口和抽象类实现了灵活的OOP设计。理解这些概念对于构建可扩展的Kotlin应用程序至关重要。

[[Category:编程语言]]
[[Category:Kotlin]]
[[Category:Kotlin面向对象编程]]