编辑“︁Kotlin方法重写”︁（章节）

= Kotlin方法重写 =

== 介绍 ==
'''方法重写'''（Method Overriding）是面向对象编程（OOP）中的一个核心概念，允许子类重新定义父类中已经定义的方法，以提供特定于子类的实现。在Kotlin中，方法重写通过关键字 `open` 和 `override` 实现，确保代码的可扩展性和多态性。

在Kotlin中，默认情况下所有类和方法都是 `final` 的，即不可被继承或重写。要允许方法被重写，必须在父类中使用 `open` 关键字标记方法，并在子类中使用 `override` 关键字显式声明重写。

== 基本语法 ==
以下是一个简单的Kotlin方法重写示例：

<syntaxhighlight lang="kotlin">
open class Animal {
    open fun makeSound() {
        println("The animal makes a sound")
    }
}

class Dog : Animal() {
    override fun makeSound() {
        println("The dog barks")
    }
}

fun main() {
    val animal: Animal = Dog()
    animal.makeSound() // 输出: The dog barks
}
</syntaxhighlight>

=== 输出 ===
<pre>
The dog barks
</pre>

=== 解释 ===
1. `Animal` 类中的 `makeSound()` 方法被标记为 `open`，表示它可以被重写。
2. `Dog` 类继承 `Animal` 并重写 `makeSound()` 方法，使用 `override` 关键字。
3. 在 `main()` 函数中，尽管变量类型是 `Animal`，但实际调用的是 `Dog` 类的实现，体现了多态性。

== 规则与注意事项 ==
1. '''父类方法必须标记为 `open`'''：Kotlin默认方法是 `final` 的，必须显式声明 `open` 才能被重写。
2. '''子类必须使用 `override` 关键字'''：否则编译器会报错。
3. '''重写方法可以调用父类实现'''：使用 `super` 关键字，例如：
   <syntaxhighlight lang="kotlin">
   override fun makeSound() {
       super.makeSound() // 调用父类方法
       println("The dog barks")
   }
   </syntaxhighlight>
4. '''属性也可以被重写'''：与方法类似，属性需要标记为 `open` 并在子类中使用 `override`。

== 实际应用案例 ==
假设我们有一个图形绘制应用程序，需要计算不同形状的面积：

<syntaxhighlight lang="kotlin">
open class Shape {
    open fun calculateArea(): Double {
        return 0.0
    }
}

class Circle(val radius: Double) : Shape() {
    override fun calculateArea(): Double {
        return Math.PI * radius * radius
    }
}

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

fun main() {
    val shapes = listOf(Circle(5.0), Rectangle(4.0, 6.0))
    shapes.forEach { println("Area: ${it.calculateArea()}") }
}
</syntaxhighlight>

=== 输出 ===
<pre>
Area: 78.53981633974483
Area: 24.0
</pre>

=== 解释 ===
- `Shape` 是基类，提供默认的 `calculateArea()` 实现。
- `Circle` 和 `Rectangle` 重写该方法，分别计算圆形和矩形的面积。
- 通过多态性，可以在运行时动态调用正确的实现。

== 方法重写与多态性 ==
方法重写是实现多态性的关键机制之一。多态性允许同一操作作用于不同的对象，产生不同的结果。以下是一个更复杂的示例：

<syntaxhighlight lang="kotlin">
open class Vehicle {
    open fun startEngine() {
        println("Engine started")
    }
}

class Car : Vehicle() {
    override fun startEngine() {
        println("Car engine started with key")
    }
}

class ElectricCar : Car() {
    override fun startEngine() {
        println("Electric car started with button")
    }
}

fun main() {
    val vehicles = listOf(Vehicle(), Car(), ElectricCar())
    vehicles.forEach { it.startEngine() }
}
</syntaxhighlight>

=== 输出 ===
<pre>
Engine started
Car engine started with key
Electric car started with button
</pre>

=== 类继承关系图 ===
<mermaid>
classDiagram
    Vehicle <|-- Car
    Car <|-- ElectricCar
    class Vehicle {
        +startEngine()
    }
    class Car {
        +startEngine()
    }
    class ElectricCar {
        +startEngine()
    }
</mermaid>

== 总结 ==
- 方法重写允许子类提供父类方法的特定实现。
- Kotlin使用 `open` 和 `override` 关键字确保显式性和安全性。
- 重写是实现多态性的基础，使代码更灵活和可扩展。
- 实际应用中，方法重写广泛用于框架设计、API扩展和业务逻辑定制。

通过理解并掌握方法重写，开发者可以更好地利用Kotlin的面向对象特性，构建可维护和可扩展的应用程序。

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