Kotlin Inheritance（继承）详解：语法、原理、实战 DemoKotlin Inheritance（继承）

Kotlin Inheritance（继承）详解：语法、原理、实战 Demo

Kotlin 的继承（Inheritance）和 Java、C# 的面向对象继承思想基本一致，但在语法和设计理念上存在几个重要区别。

其中最核心的一点是：

Kotlin 的类和成员默认都是 final，必须显式使用 open 才能允许继承或重写。

例如：

open class Animal {
    open fun speak() {
        println("动物发出声音")
    }
}

class Dog : Animal() {
    override fun speak() {
        println("汪汪")
    }
}

本篇结合 Kotlin 官方文档，详细讲解继承的语法、构造函数、方法重写、属性重写、多态、抽象类、多继承冲突、初始化顺序，以及 Spring Boot 实战。

官方文档：Kotlin Inheritance

一、Kotlin 继承的基本概念

继承允许一个类复用另一个类的可继承成员，并在此基础上扩展或修改行为。

例如，我们有一个动物类：

open class Animal {
    fun eat() {
        println("动物正在吃东西")
    }
}

定义子类：

class Dog : Animal() {
    fun bark() {
        println("汪汪")
    }
}

调用：

fun main() {
    val dog = Dog()

    dog.eat()
    dog.bark()
}

输出：

动物正在吃东西
汪汪

这里的继承关系是：

在 Kotlin 中：

Animal 是父类（Superclass）。
Dog 是子类（Subclass）。
open 表示允许继承。
: 表示继承或实现接口。
Animal() 表示调用父类构造函数。

与 Java 不同，Kotlin 不使用 extends 关键字。

二、为什么 Kotlin 默认禁止继承？

先看下面的代码：

class Animal {
    fun eat() {
        println("eat")
    }
}

// 编译错误
class Dog : Animal()

原因是 Kotlin 的普通类默认不可继承。

必须修改为：

open class Animal {
    fun eat() {
        println("eat")
    }
}

class Dog : Animal()

Java、C#、Kotlin 对比：

特性	Kotlin	Java	C#
类默认能否继承	否	可以	可以
允许继承	`open class`	默认允许	默认允许
禁止继承	默认或 `final`	`final`	`sealed`
方法默认可重写	否	通常可以	否
允许方法重写	`open`	非 `final` 的实例方法	`virtual` / `abstract`
重写方法	`override`	`@Override`	`override`

Kotlin 采用的是默认封闭，显式开放的设计思想。

好处是开发者必须明确哪些类、哪些成员属于可扩展的 API，减少无意继承和重写造成的问题。

三、open、override、final 关键字

这是 Kotlin 继承最重要的三个关键字。

1. open：允许重写

open class Animal {

    open fun speak() {
        println("Animal speak")
    }

    fun eat() {
        println("Animal eat")
    }
}

其中：

open fun speak()

可以被子类重写。

但：

fun eat()

默认不能重写。

2. override：重写父类方法

class Dog : Animal() {

    override fun speak() {
        println("Dog bark")
    }
}

调用：

fun main() {
    val dog = Dog()

    dog.speak()
    dog.eat()
}

输出：

Dog bark
Animal eat

3. final：禁止进一步重写

需要注意一个细节：

Kotlin 中，被 override 重写的方法默认仍然允许继续重写。

例如：

open class Animal {
    open fun speak() {
        println("Animal")
    }
}

open class Dog : Animal() {
    override fun speak() {
        println("Dog")
    }
}

class Husky : Dog() {
    override fun speak() {
        println("Husky")
    }
}

如果希望 Dog.speak() 不再允许子类重写：

open class Dog : Animal() {

    final override fun speak() {
        println("Dog")
    }
}

此时：

class Husky : Dog() {

    // 编译错误
    override fun speak() {
        println("Husky")
    }
}

因为 Dog.speak() 已经被声明为 final。

四、继承与构造函数

Kotlin 的构造函数与 Java、C# 不太一样。

Kotlin 支持：

主构造函数（Primary Constructor）。
次构造函数（Secondary Constructor）。

继承时必须正确初始化父类。

1. 父类有主构造函数

open class Animal(
    val name: String,
    val age: Int
) {
    fun info() {
        println("name=$name, age=$age")
    }
}

子类：

class Dog(
    name: String,
    age: Int,
    val breed: String
) : Animal(name, age)

使用：

fun main() {
    val dog = Dog(
        name = "旺财",
        age = 3,
        breed = "柴犬"
    )

    dog.info()
    println(dog.breed)
}

输出：

name=旺财, age=3
柴犬

重点：

class Dog(
    name: String,
    age: Int,
    val breed: String
) : Animal(name, age)

name、age 是传给父类的构造参数。

因为它们没有在 Dog 构造参数前使用 val 或 var，所以不会为 Dog 额外声明同名属性。

父类已经声明了：

val name: String
val age: Int

子类可以直接使用继承来的属性。

2. 子类没有主构造函数

如果子类只有次构造函数，可以使用 super(...) 调用父类构造函数。

open class Person(
    val name: String
)

class Student : Person {

    val score: Int

    constructor(name: String, score: Int) : super(name) {
        this.score = score
    }
}

fun main() {
    val student = Student("Tom", 95)

    println(student.name)
    println(student.score)
}

输出：

Tom
95

这里：

constructor(name: String, score: Int) : super(name)

表示在次构造函数中初始化父类。

规则：如果子类声明了主构造函数，父类的主构造函数调用通常写在类头部；如果子类没有主构造函数，则每个次构造函数必须直接或间接完成父类初始化。

五、super：调用父类方法

子类重写父类方法时，有时候希望保留父类原有逻辑。

open class Animal {

    open fun speak() {
        println("Animal speak")
    }
}

class Dog : Animal() {

    override fun speak() {
        super.speak()
        println("Dog bark")
    }
}

fun main() {
    Dog().speak()
}

输出：

Animal speak
Dog bark

这里：

super.speak()

调用父类的实现。

实战：统一日志处理

open class BaseService {

    open fun execute() {
        println("基础业务逻辑")
    }
}

class OrderService : BaseService() {

    override fun execute() {
        println("开始处理订单")

        super.execute()

        println("订单处理完成")
    }
}

这种写法在需要扩展父类行为时很常见。

不过，在复杂业务系统中，如果父类承担过多逻辑，可能会造成继承层级过深，因此不应为了复用几行代码就建立继承关系。

六、属性重写（Property Overriding）

Kotlin 不仅可以重写方法，还可以重写属性。

1. 重写 val 属性

open class Animal {

    open val name: String = "Animal"
}

class Dog : Animal() {

    override val name: String = "Dog"
}

fun main() {
    val animal: Animal = Dog()

    println(animal.name)
}

输出：

Dog

这里虽然变量声明为：

val animal: Animal

但实际对象是 Dog，访问开放属性时会发生动态分派。

2. 使用 getter 重写

open class Shape {

    open val area: Double
        get() = 0.0
}

class Rectangle(
    val width: Double,
    val height: Double
) : Shape() {

    override val area: Double
        get() = width * height
}

fun main() {
    val shape: Shape = Rectangle(10.0, 5.0)

    println(shape.area)
}

输出：

50.0

3. 可以用 var 重写 val 吗？

可以。

open class User {

    open val name: String = "Guest"
}

class Admin : User() {

    override var name: String = "Admin"
}

原因是：

val 只要求提供读取能力。
var 同时提供读取和写入能力。

因此，var 可以满足 val 的契约。

反过来则不行：

open class User {
    open var name: String = "Guest"
}

class Admin : User() {

    // 编译错误
    override val name: String = "Admin"
}

因为父类要求可写，而子类却移除了写入能力。

七、继承与多态（Polymorphism）

这是面向对象编程的核心。

假设有一个支付系统：

open class Payment {

    open fun pay(amount: Double) {
        println("支付金额：$amount")
    }
}

支付宝：

class AliPay : Payment() {

    override fun pay(amount: Double) {
        println("支付宝支付：$amount")
    }
}

微信支付：

class WeChatPay : Payment() {

    override fun pay(amount: Double) {
        println("微信支付：$amount")
    }
}

业务方法：

fun checkout(payment: Payment, amount: Double) {
    payment.pay(amount)
}

调用：

fun main() {
    checkout(AliPay(), 100.0)
    checkout(WeChatPay(), 200.0)
}

输出：

支付宝支付：100.0
微信支付：200.0

checkout() 并不关心实际对象是 AliPay 还是 WeChatPay。

运行时根据对象实际类型调用对应的 pay()。

这就是动态分派（Dynamic Dispatch）。

不过，对于支付能力这样的业务抽象，实际开发中通常更适合使用 interface Payment，而不是继承一个带有默认业务实现的普通类。

八、抽象类（Abstract Class）

抽象类不能直接实例化，可以定义抽象方法和普通方法。

abstract class Animal {

    abstract fun speak()

    fun sleep() {
        println("动物正在睡觉")
    }
}

子类：

class Cat : Animal() {

    override fun speak() {
        println("喵喵")
    }
}

调用：

fun main() {
    val cat = Cat()

    cat.speak()
    cat.sleep()
}

输出：

喵喵
动物正在睡觉

抽象类具有以下特点：

不能直接实例化。
可以有构造函数。
可以有成员变量。
可以有普通方法和抽象方法。
抽象成员不需要额外声明 open。
非抽象成员仍然遵循 Kotlin 的 open / final 规则。

实战：模板方法模式

假设开发一个数据导入系统，支持 CSV、Excel 等文件。

导入过程固定：

读取文件。
解析数据。
校验数据。
保存数据。

但不同格式的解析逻辑不同。

可以使用抽象类：

abstract class DataImporter {

    fun import(filePath: String) {
        val content = readFile(filePath)
        val records = parse(content)

        validate(records)
        save(records)
    }

    protected open fun readFile(filePath: String): String {
        println("读取文件：$filePath")
        return "mock-data"
    }

    protected abstract fun parse(content: String): List<String>

    protected open fun validate(records: List<String>) {
        println("校验 ${records.size} 条数据")
    }

    protected open fun save(records: List<String>) {
        println("保存 ${records.size} 条数据")
    }
}

CSV 实现：

class CsvImporter : DataImporter() {

    override fun parse(content: String): List<String> {
        println("解析 CSV")
        return listOf("Tom", "Jack")
    }
}

Excel 实现：

class ExcelImporter : DataImporter() {

    override fun parse(content: String): List<String> {
        println("解析 Excel")
        return listOf("Alice", "Bob", "Lucy")
    }
}

调用：

fun main() {
    val csv = CsvImporter()
    csv.import("users.csv")

    println("----------")

    val excel = ExcelImporter()
    excel.import("users.xlsx")
}

输出：

读取文件：users.csv
解析 CSV
校验 2 条数据
保存 2 条数据
----------
读取文件：users.xlsx
解析 Excel
校验 3 条数据
保存 3 条数据

这就是经典的 Template Method Pattern（模板方法模式）。

在 Java、C# 中也经常使用这种设计模式。

九、Kotlin 支持多继承吗？

Kotlin 不支持同时继承多个类。

例如：

open class A
open class B

// 编译错误
class C : A(), B()

但 Kotlin 支持：

继承一个类，同时实现多个接口。

例如：

open class Animal {
    fun eat() {
        println("eat")
    }
}

interface Flyable {
    fun fly()
}

interface Swimmable {
    fun swim()
}

class Duck : Animal(), Flyable, Swimmable {

    override fun fly() {
        println("飞行")
    }

    override fun swim() {
        println("游泳")
    }
}

十、接口默认方法冲突

如果两个接口定义了相同签名且有默认实现的方法，子类必须明确处理冲突。

interface A {

    fun hello() {
        println("A")
    }
}

interface B {

    fun hello() {
        println("B")
    }
}

错误写法：

class C : A, B

编译器无法判断应该继承哪个默认实现。

正确写法：

class C : A, B {

    override fun hello() {
        super<A>.hello()
        super<B>.hello()
    }
}

调用：

fun main() {
    C().hello()
}

输出：

A
B

这里：

super<A>.hello()

表示调用接口 A 的默认实现。

super<B>.hello()

表示调用接口 B 的默认实现。

如果父类和接口都提供了同名、同签名的可继承实现，也需要根据继承规则解决冲突。

十一、初始化顺序：继承中最容易踩坑的问题

Kotlin 对象初始化顺序很重要。

例如：

open class Base(
    val name: String
) {

    init {
        println("Base init: $name")
    }
}

class Derived(
    name: String,
    val age: Int
) : Base(name) {

    init {
        println("Derived init: $age")
    }
}

fun main() {
    Derived("Tom", 20)
}

输出：

Base init: Tom
Derived init: 20

通常可以理解为：

计算传递给父类构造函数的参数。
执行父类初始化。
执行子类属性初始化和 init 块，按源码声明顺序进行。

危险场景：父类初始化时访问 open 属性

open class Base {

    open val name: String = "Base"

    init {
        println("Base init: $name")
    }
}

class Derived : Base() {

    override val name: String = "Derived"
}

fun main() {
    Derived()
}

这里可能输出：

Base init: null

原因是：

父类初始化时访问 name，发生动态分派，调用了子类属性的 getter。

但是此时子类的属性初始化还没有完成，因此可能读取到 JVM 字段的默认值 null。

这是一个很危险的问题。

最佳实践：不要在父类构造函数、属性初始化器或 init 块中调用可能被子类重写的成员。

即使属性在 Kotlin 类型系统中声明为非空，也不能保证这种初始化顺序下不会观察到未初始化状态。

十二、protected、private、internal 与继承

Kotlin 的可见性修饰符：

修饰符	类外访问	子类访问	说明
`public`	可以	可以	默认
`private`	不可以	不可以直接访问	仅声明范围内
`protected`	不可以	可以	当前类及子类
`internal`	同模块可以	同模块可以	模块级可见

示例：

open class BaseService {

    private val secret = "private"

    protected val token = "protected"

    internal val config = "internal"

    fun execute() {
        println("public")
    }
}

子类：

class UserService : BaseService() {

    fun test() {
        println(token)
        println(config)

        // println(secret) // 编译错误
    }
}

注意：internal 是模块可见性，不是“包可见性”，与 Java 的 package-private 不同。

十三、继承与扩展函数的区别

继承的重写方法支持动态分派：

open class Animal {

    open fun speak() {
        println("Animal")
    }
}

class Dog : Animal() {

    override fun speak() {
        println("Dog")
    }
}

fun main() {
    val animal: Animal = Dog()

    animal.speak()
}

输出：

Dog

但是扩展函数采用静态解析：

open class Animal
class Dog : Animal()

fun Animal.speak() {
    println("Animal Extension")
}

fun Dog.speak() {
    println("Dog Extension")
}

fun main() {
    val animal: Animal = Dog()

    animal.speak()
}

输出：

Animal Extension

因为编译器根据变量的声明类型 Animal 选择扩展函数，而不是运行时对象的 Dog 类型。

对比	成员方法重写	扩展函数
分派方式	动态分派	静态解析
是否需要继承	通常需要	不需要
能否重写已有成员	可以，需 `open`	不可以
适合场景	多态业务行为	工具方法、API 扩展

十四、继承与 Delegation（委托）的区别

继承

open class Logger {

    open fun log(message: String) {
        println(message)
    }
}

class FileLogger : Logger() {

    override fun log(message: String) {
        println("File: $message")
    }
}

委托

interface Logger {
    fun log(message: String)
}

class ConsoleLogger : Logger {

    override fun log(message: String) {
        println(message)
    }
}

class FileLogger(
    logger: Logger
) : Logger by logger

区别：

特性	继承	委托
复用方式	继承父类实现	组合并转发给对象
耦合程度	通常较高	通常较低
能否动态更换实现	不方便	可通过组合设计实现
适合场景	稳定的 is-a 关系	可组合的行为
是否支持父类虚方法分派	支持	不自动实现相同语义

例如：

Dog 是一种 Animal：适合继承。
OrderService 使用一个 Logger：适合组合或委托。

实际业务系统中，优先考虑接口 + 组合；当确实存在稳定的类型层次或模板行为时，再考虑继承。

十五、Spring Boot 实战：抽象 Service 基类

在 Kotlin + Spring Boot 项目中，可以使用抽象类复用通用业务逻辑。

例如开发一个基础 CRUD Service。

1. 定义实体

data class User(
    val id: Long,
    val name: String
)

2. 定义 Repository 接口

interface CrudRepository<T, ID> {

    fun findById(id: ID): T?

    fun save(entity: T): T

    fun deleteById(id: ID)
}

这里是演示用的自定义接口，不是 Spring Data 自带的 CrudRepository。

3. 定义抽象 Service

abstract class BaseCrudService<T, ID>(
    protected val repository: CrudRepository<T, ID>
) {

    open fun findById(id: ID): T? {
        return repository.findById(id)
    }

    open fun save(entity: T): T {
        return repository.save(entity)
    }

    open fun deleteById(id: ID) {
        repository.deleteById(id)
    }
}

4. 定义 UserService

class UserService(
    repository: CrudRepository<User, Long>
) : BaseCrudService<User, Long>(repository) {

    override fun save(entity: User): User {
        require(entity.name.isNotBlank()) {
            "用户名不能为空"
        }

        return super.save(entity)
    }
}

5. 定义内存 Repository

class InMemoryUserRepository : CrudRepository<User, Long> {

    private val data = mutableMapOf<Long, User>()

    override fun findById(id: Long): User? {
        return data[id]
    }

    override fun save(entity: User): User {
        data[entity.id] = entity
        return entity
    }

    override fun deleteById(id: Long) {
        data.remove(id)
    }
}

6. 测试

fun main() {
    val repository = InMemoryUserRepository()
    val service = UserService(repository)

    service.save(User(1, "Tom"))
    service.save(User(2, "Jack"))

    println(service.findById(1))

    service.deleteById(2)

    println(service.findById(2))
}

输出：

User(id=1, name=Tom)
null

这个例子将以下 Kotlin 特性组合起来：

abstract class：抽象类。
<T, ID>：泛型。
protected：受保护成员。
open：允许重写。
override：重写业务方法。
super：调用父类逻辑。
interface：仓储契约。

需要特别注意：Spring Boot 中的 @Transactional、@Cacheable 等基于代理的功能可能涉及类和方法是否可代理。Kotlin 类默认 final，因此 Spring 项目通常使用 kotlin-spring（all-open）编译器插件，为特定 Spring 注解类及成员生成适合代理的开放声明。

官方参考：Kotlin all-open Compiler Plugin。

十六、Kotlin 的 sealed class 和继承

还有一个值得学习的知识点：sealed class（密封类）。

它与 open class 不同。

sealed class ApiResult {

    data class Success(
        val data: String
    ) : ApiResult()

    data class Error(
        val message: String
    ) : ApiResult()

    data object Loading : ApiResult()
}

使用：

fun handle(result: ApiResult) {

    when (result) {
        is ApiResult.Success -> {
            println(result.data)
        }

        is ApiResult.Error -> {
            println(result.message)
        }

        ApiResult.Loading -> {
            println("加载中")
        }
    }
}

因为 ApiResult 是密封类，编译器能够了解受限制的直接继承层次，帮助检查 when 是否穷尽。

需要注意：sealed 不是彻底禁止继承，而是限制直接子类的声明位置和模块边界；符合规则的非密封子类仍可能继续被继承。

这非常适合：

API 请求结果。
业务状态。
订单状态机。
UI 状态。
错误类型建模。

官方参考：Kotlin Sealed Classes。

十七、常见错误总结

错误写法或理解	原因	正确做法
`class Dog : Animal()`，但 `Animal` 没有 `open`	父类默认 final	`open class Animal`
重写普通方法	方法默认 final	父类方法加 `open`
`override` 后认为不能再重写	override 默认仍开放	使用 `final override`
`var` 属性用 `val` 重写	丢失写入能力	用 `var` 重写
同时继承两个普通类	Kotlin 不支持类多继承	一个父类 + 多个接口
父类 `init` 访问开放属性	子类可能尚未初始化	避免构造期间调用开放成员
把 Extension 当作多态	扩展函数静态解析	使用真正的成员重写
认为继承总比组合方便	继承容易形成强耦合	优先根据业务关系选择