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

一、类定义的核心语法

1.1 基础类声明

Kotlin中类的声明通过class关键字实现，支持简洁的语法结构：

class Person {
    var name: String = "Anonymous"
    fun greet() {
        println("Hello, $name!")
    }
}

这种声明方式与Java类似，但Kotlin通过类型推断和默认参数简化了代码。实例化时直接使用Person().greet()即可调用。

1.2 主构造函数特性

Kotlin将构造函数与类头合并，形成独特的语法结构：

class Student(val id: Int, var score: Double) {
    init {
        println("Student $id initialized with score $score")
    }
}

• val/var修饰符：直接声明为类属性
• init块：在对象创建时立即执行
• 参数默认值：支持class Book(val title: String = "Untitled")

1.3 次构造函数与扩展

通过constructor关键字可定义多个构造方法：

class Rectangle {
    var width: Double = 0.0
    var height: Double = 0.0
    constructor(w: Double, h: Double) {
        width = w
        height = h
    }
    constructor(size: Double) : this(size, size)
}

次构造函数必须委托给主构造函数或其他次构造函数（使用this关键字），这保证了对象初始化的唯一性。

二、继承机制详解

2.1 开放类与继承规则

Kotlin默认所有类为final，需显式使用open修饰符允许继承：

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

关键规则：

• 父类方法重写需open修饰
• 子类重写需override修饰
• 禁止多重继承（通过接口实现多态）

2.2 属性继承与覆盖

属性继承比Java更灵活，支持覆盖getter/setter：

open class Shape {
    open val vertexCount: Int = 0
}
class Triangle : Shape() {
    override val vertexCount: Int = 3
}

对于可变属性，需保持类型兼容：

open class Container {
    open var content: String = "empty"
}
class Box : Container() {
    override var content: String = "box content" // 必须保持String类型
}

2.3 抽象类与接口

抽象类实现：

abstract class Vehicle {
    abstract val maxSpeed: Double
    fun start() {
        println("Vehicle started")
    }
}
class Car : Vehicle() {
    override val maxSpeed: Double = 220.0
}

接口特性：

interface Flyable {
    val flightSpeed: Double
    fun takeOff() {
        println("Taking off...")
    }
}
class Bird : Animal("Sparrow"), Flyable {
    override val flightSpeed: Double = 15.0
    override fun makeSound() {
        println("Chirp!")
    }
}

接口支持属性声明和默认方法实现，实现类需覆盖所有抽象成员。

三、高级继承技巧

3.1 继承中的构造函数链

复杂继承场景下的构造顺序：

open class Base(val baseParam: Int) {
    init {
        println("Base initialized with $baseParam")
    }
}
class Derived(param: Int) : Base(param) {
    init {
        println("Derived initialized")
    }
}

执行顺序：父类主构造 → 父类init块 → 子类主构造 → 子类init块

3.2 类型检查与智能转换

Kotlin提供安全的类型检查机制：

fun printSound(animal: Animal) {
    when (animal) {
        is Dog -> println(animal.makeSound()) // 智能转换为Dog类型
        is Cat -> println("Meow!")
        else -> println("Unknown animal")
    }
}

is检查后，编译器自动将对象转换为指定类型。

3.3 覆盖规则限制

通过final限制子类覆盖：

open class Controller {
    open fun process() = println("Processing...")
    final fun validate() = println("Validation complete")
}
class AdvancedController : Controller() {
    override fun process() = println("Advanced processing")
    // validate() 不能被重写
}

四、最佳实践建议

1. 优先使用组合而非继承：遵循”组合优于继承”原则，通过by关键字实现委托：

   class DelegatedList<T>(private val innerList: MutableList<T> = mutableListOf()) 
    : MutableList<T> by innerList

2. 密封类优化模式匹配：对于有限继承层次，使用sealed class：
   ```kotlin
   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(result.data)
is Result.Failure -> println(“Error: ${result.error.message}”)
}

3. **数据类继承**：数据类默认`final`，需显式开放：
```kotlin
open class Person(val name: String)
data class Employee(val id: Int, name: String) : Person(name)

1. 扩展函数替代继承：通过扩展函数增强类功能：
   ```kotlin
   fun String.addExclamation(): String = “$this!”

“Hello”.addExclamation() // 返回”Hello!”

## 五、常见问题解决方案
1. **继承中的属性初始化冲突**：
   ```kotlin
   open class Parent {
       open val value: Int = 10
   }
   class Child : Parent() {
       override val value: Int = 20 // 正确
       // val value = 30 // 错误：与父类属性冲突
   }

1. 开放类与数据类的结合：

   open class BaseData(val id: Int)
   data class DerivedData(id: Int, val name: String) : BaseData(id)
   // 自动生成equals/hashCode仅包含id和name

2. 接口中的属性实现：

   interface Identifiable {
       val id: Int
   }
   class User : Identifiable {
       override val id: Int = 100 // 必须为val或var
   }

通过系统掌握这些类定义与继承机制，开发者能够编写出更灵活、可维护的Kotlin代码。实际开发中，建议结合Android Studio的代码分析工具，实时检查继承关系的正确性，并利用Kotlin的空安全特性减少NPE风险。