Kotlin第五讲：深入解析类定义与继承机制

一、类定义：从基础到高级的语法特性

1.1 主构造函数与初始化块

Kotlin的类定义以class关键字开头，其核心特性之一是主构造函数（Primary Constructor），它直接与类名绑定，简化对象创建流程。例如：

class Person(val name: String, var age: Int) {
    init {
        println("Person $name is initialized with age $age")
    }
}

• 参数声明：主构造函数参数可声明为val（只读）或var（可读写），自动成为类的属性。
• 初始化块：init块在对象创建时立即执行，常用于参数校验或默认值设置。例如，可添加require(age >= 0)确保年龄非负。

1.2 次构造函数与委托

当需要支持多种构造方式时，可通过次构造函数（Secondary Constructor）扩展：

class Student {
    var name: String = ""
    var age: Int = 0
    constructor(name: String) : this() {
        this.name = name
    }
    constructor(name: String, age: Int) : this(name) {
        this.age = age
    }
}

• 委托调用：次构造函数必须通过this()委托给主构造函数或其他次构造函数，确保初始化逻辑集中。
• 适用场景：次构造函数适合处理可选参数或兼容旧API的场景。

1.3 可见性修饰符与嵌套类

Kotlin通过修饰符控制类成员的访问权限：

• public（默认）：所有位置可见。
• internal：同一模块内可见。
• protected：子类中可见（仅限类成员）。
• private：类内部可见。

嵌套类（Nested Class）默认不持有外部类引用，需使用inner关键字显式关联：

class Outer {
    private val value = 10
    inner class Inner {
        fun printValue() = println(value) // 可访问外部类私有成员
    }
}

二、继承机制：单继承与接口实现的差异

2.1 开放类与继承限制

Kotlin默认所有类为final，需显式使用open关键字允许继承：

open class Animal(val name: String) {
    open fun makeSound() = println("Some sound")
}
class Dog(name: String) : Animal(name) {
    override fun makeSound() = println("Woof!")
}

• 方法重写：需用override标记，且基类方法必须声明为open。
• 属性重写：支持val重写为var，但反向不兼容。

2.2 抽象类与接口对比

抽象类（Abstract Class）

• 可包含抽象方法（无实现）和具体方法。
• 适合定义共享逻辑的基类：
  ```kotlin
  abstract class Shape {
  abstract fun area(): Double
  fun printArea() = println(“Area: ${area()}”)
  }

class Circle(val radius: Double) : Shape() {
override fun area() = Math.PI radius radius
}

#### 接口（Interface）
- Kotlin接口可包含属性（需抽象或提供getter）和方法实现：
```kotlin
interface Flyable {
    val maxAltitude: Double // 抽象属性
    fun fly() = println("Flying at $maxAltitude meters")
}
class Bird(override val maxAltitude: Double) : Flyable {
    override fun fly() {
        println("Bird flying at $maxAltitude meters")
        super.fly() // 调用接口默认实现
    }
}

• 多继承支持：类可实现多个接口，解决Java单继承限制。

2.3 密封类（Sealed Class）与模式匹配

密封类限制子类为同一文件内的有限集合，常用于状态机或结果处理：

sealed class Result {
    class Success(val data: String) : Result()
    class Failure(val error: Throwable) : Result()
}
fun handleResult(result: Result) {
    when (result) {
        is Result.Success -> println("Data: ${result.data}")
        is Result.Failure -> println("Error: ${result.error.message}")
    }
}

• 优势：编译器可检查所有子类，避免else分支。

三、最佳实践与常见陷阱

3.1 数据类（Data Class）简化实体定义

对于仅包含数据的类，使用data关键字自动生成equals()、hashCode()和toString()：

data class User(val id: Int, val name: String)
val user1 = User(1, "Alice")
val user2 = User(1, "Alice")
println(user1 == user2) // true（自动比较字段）

3.2 避免过度使用继承

优先选择组合而非继承，符合“组合优于继承”原则。例如，用属性委托实现功能复用：

class Logger {
    fun log(message: String) = println("LOG: $message")
}
class Service(private val logger: Logger) {
    fun execute() {
        logger.log("Service executed")
    }
}

3.3 接口隔离与默认方法

将大接口拆分为小接口，通过默认方法减少子类负担：

interface Reader {
    fun read(): String
}
interface Writer {
    fun write(text: String)
}
interface ReadWrite : Reader, Writer {
    override fun read() = "Default read" // 可选重写
}

四、总结与进阶建议

Kotlin的类与继承机制通过语法糖（如主构造函数）和强限制（如默认final类）提升了代码安全性。开发者应：

1. 优先使用组合：仅在存在“is-a”关系时使用继承。
2. 合理设计接口：利用默认方法避免“胖接口”。
3. 利用密封类：简化状态管理和错误处理。

通过掌握这些特性，可编写出更简洁、可维护的Kotlin代码。下一讲将深入探讨Kotlin的协程与异步编程模型。