Kotlin 继承：面向对象编程的基石
在 Kotlin 中，继承是实现代码复用和构建层次化类结构的核心机制。它允许我们基于已有类创建新类，继承其属性和方法，同时还能扩展或重写功能。这就像盖房子时，先有一个基础户型图，后续可以根据需求加房间、改布局，而不需要从零开始设计整栋楼。
对于初学者来说，理解 Kotlin 继承不仅能提升代码组织能力，还能为后续学习多态、接口等高级概念打下坚实基础。本文将带你一步步掌握 Kotlin 继承的使用方式，从基础语法到实际应用，结合真实场景讲解，帮助你真正掌握这一重要特性。
类的继承基础语法
在 Kotlin 中，使用 : 符号来声明一个类继承自另一个类。被继承的类称为父类（或超类），继承它的类称为子类（或派生类）。
// 定义一个父类 Animal
open class Animal {
// 父类的属性
var name: String = ""
var age: Int = 0
// 父类的方法
fun eat() {
println("$name 正在吃东西")
}
fun sleep() {
println("$name 正在睡觉")
}
}
注意：在 Kotlin 中，默认所有类都是 final 的，即不能被继承。如果希望某个类可以被继承，必须显式使用
open关键字。
// 子类 Dog 继承自 Animal
class Dog : Animal() {
// Dog 特有的属性
var breed: String = ""
// 重写父类的方法
override fun eat() {
println("$name 正在啃骨头")
}
// 子类独有的方法
fun bark() {
println("$name 在汪汪叫")
}
}
关键点说明：
class Dog : Animal()中的括号()是调用父类的无参构造函数，如果父类有带参数的构造函数，这里需要传参。override fun eat()表示这个方法是重写父类的方法，必须加override关键字。open是 Kotlin 中允许继承的关键修饰符，不加则无法被继承。
继承中的构造函数与初始化
Kotlin 中的构造函数继承与 Java 有明显区别。子类必须在声明时就完成对父类的初始化，这通过主构造函数实现。
// 父类带有参数的构造函数
open class Animal constructor(val name: String, val age: Int) {
init {
println("动物 $name 创建成功，年龄：$age 岁")
}
fun eat() {
println("$name 正在吃东西")
}
}
// 子类继承父类构造函数参数
class Dog(name: String, age: Int, val breed: String) : Animal(name, age) {
init {
println("狗 $name 已经被创建，品种：$breed")
}
override fun eat() {
println("$name 正在吃狗粮")
}
fun bark() {
println("$name 在叫：汪汪！")
}
}
使用示例：
fun main() {
val dog = Dog("旺财", 3, "金毛")
dog.eat() // 输出：旺财 正在吃狗粮
dog.bark() // 输出：旺财 在叫：汪汪！
}
重要提示：
- 子类的主构造函数必须在
: Animal(...)中调用父类构造函数。- 如果父类没有无参构造函数，子类必须显式传参。
init块在构造函数执行前后自动运行，可用于初始化逻辑。
方法重写与 override 的使用
方法重写是 Kotlin 继承中最重要的功能之一。当子类希望改变父类的行为时，可以使用 override 关键字重写方法。
open class Vehicle {
open fun start() {
println("车辆启动中...")
}
open fun stop() {
println("车辆停止")
}
}
class Car : Vehicle() {
override fun start() {
println("汽车启动：引擎轰鸣，准备出发！")
}
override fun stop() {
println("汽车刹车，平稳停下")
}
}
class Motorcycle : Vehicle() {
override fun start() {
println("摩托车启动：轰隆一声，加速向前！")
}
}
运行测试：
fun main() {
val car = Car()
val bike = Motorcycle()
car.start() // 输出：汽车启动：引擎轰鸣，准备出发！
bike.start() // 输出：摩托车启动：轰隆一声，加速向前！
}
注意：
open修饰的方法才能被重写。- 重写的方法必须使用
override关键字。- 如果父类方法是
final（默认），则不能被重写。
属性继承与 override 的使用
Kotlin 不仅支持方法继承，也支持属性继承。子类可以重写父类的属性，但必须显式使用 override。
open class Animal {
open val sound: String = "动物叫声"
}
class Dog : Animal() {
override val sound: String = "汪汪！"
}
class Cat : Animal() {
override val sound: String = "喵喵~"
}
使用示例：
fun main() {
val animals = listOf(Dog(), Cat())
for (animal in animals) {
println("发出的声音是：${animal.sound}")
}
// 输出：
// 发出的声音是：汪汪！
// 发出的声音是：喵喵~
}
关键点：
open val表示该属性可被重写。- 重写属性时，必须使用
override。- 属性重写时，类型必须一致或兼容。
多层继承与类层次结构
Kotlin 支持多层继承，即一个类可以继承自另一个子类，形成树状结构。
open class Animal {
open fun move() {
println("动物在移动")
}
}
class Mammal : Animal() {
override fun move() {
println("哺乳动物用四肢行走")
}
}
class Dog : Mammal() {
override fun move() {
println("狗在奔跑")
}
fun fetch() {
println("狗在捡球")
}
}
运行示例：
fun main() {
val dog = Dog()
dog.move() // 输出：狗在奔跑
dog.fetch() // 输出：狗在捡球
}
形象比喻：这就像一个家族树，从“动物”这个祖先开始，到“哺乳动物”，再到“狗”，每一代都继承上一代的特性，并在此基础上发展出自己的特点。
实际应用场景：图形类的设计
我们来设计一个简单的图形系统，展示 Kotlin 继承的实际用途。
// 抽象父类 Shape，表示所有图形
open abstract class Shape {
abstract fun area(): Double
abstract fun perimeter(): Double
fun draw() {
println("正在绘制图形")
}
}
// 具体子类：圆形
class Circle(val radius: Double) : Shape() {
override fun area(): Double {
return Math.PI * radius * radius
}
override fun perimeter(): Double {
return 2 * Math.PI * radius
}
}
// 具体子类：矩形
class Rectangle(val width: Double, val height: Double) : Shape() {
override fun area(): Double {
return width * height
}
override fun perimeter(): Double {
return 2 * (width + height)
}
}
使用示例：
fun main() {
val shapes = listOf(
Circle(5.0),
Rectangle(4.0, 6.0)
)
for (shape in shapes) {
println("面积：${shape.area()}")
println("周长：${shape.perimeter()}")
shape.draw()
println("---")
}
}
输出结果：
面积：78.53981633974483
周长：31.41592653589793
正在绘制图形
---
面积：24.0
周长：20.0
正在绘制图形
---
设计亮点：
- 使用
abstract class定义抽象基类，强制子类实现抽象方法。- 继承结构清晰，便于扩展新图形类型。
- 代码复用性强，
draw()方法在所有图形中通用。
总结：Kotlin 继承的核心价值
Kotlin 继承不仅仅是语法糖，它是构建可维护、可扩展代码的基础。通过继承，我们能够：
- 复用已有代码：避免重复编写相同逻辑。
- 实现多态：同一种调用，不同行为，提升代码灵活性。
- 构建清晰结构：类之间形成层次关系，逻辑更清晰。
- 支持面向对象设计原则：如开闭原则（对扩展开放，对修改关闭）。
掌握 Kotlin 继承，是迈向高级 Kotlin 编程的第一步。无论你是初学者还是中级开发者，理解并熟练运用这一机制，都将显著提升你的编码效率与代码质量。
未来，你还可以结合接口、委托、泛型等特性，构建更强大的系统架构。而这一切，都始于对 Kotlin 继承的深入理解。