Kotlin类与对象实战：从基础到高级特性解析

长沮

1. Kotlin 类与对象深度解析

作为一名从Java转向Kotlin的开发者，我深刻体会到Kotlin在面向对象编程方面的简洁与强大。今天我想分享在实际项目中积累的Kotlin类和对象使用经验，这些内容帮助我们的团队将代码量减少了30%的同时提升了可维护性。

Kotlin的类系统看似简单，实则暗藏玄机。与Java不同，Kotlin通过精心的设计消除了大量样板代码，让开发者能更专注于业务逻辑。本文适合有以下基础的读者：

了解基本编程概念
接触过面向对象编程
希望深入掌握Kotlin特性

我们将从最基础的类定义开始，逐步深入到属性委托、伴生对象等高级特性，每个环节都会配有我在实际项目中的使用案例和踩坑经验。

2. 类定义与对象创建

2.1 类的基本结构

Kotlin中使用class关键字定义类，这是最基础的语法：

kotlin复制class Person {
    var name: String = ""
    var age: Int = 0
    
    fun introduce() {
        println("Hi, I'm $name, $age years old.")
    }
}

这段看似简单的代码其实有几个关键点需要注意：

属性必须初始化（要么声明时初始化，要么在init块中初始化）
方法默认是public final的
整个类默认也是final的（不可继承）

提示：在Android开发中，建议对实体类使用data class，对工具类使用object，普通class通常用于需要继承的场景。

2.2 构造函数的秘密

Kotlin的构造函数分为主构造函数和次构造函数：

kotlin复制class Person(
    val name: String,  // 使用val使属性不可变
    var age: Int       // 使用var使属性可变
) {
    // 次构造函数必须直接或间接委托给主构造函数
    constructor(name: String) : this(name, 0) {
        println("Secondary constructor called")
    }
    
    init {
        require(age >= 0) { "Age cannot be negative" }
    }
}

实际项目经验：

80%的情况只需要主构造函数
使用init块进行参数验证
次构造函数在需要多种构造方式时很有用（如从不同数据源构建对象）

2.3 对象创建与初始化顺序

创建对象时各部分的执行顺序很重要：

kotlin复制val person = Person("Alice", 25)

初始化顺序：

主构造函数参数
类体内属性初始化
init块
次构造函数体

这个顺序在复杂的类继承关系中尤为重要，我在一个项目中就曾因为不了解这个顺序导致NPE（空指针异常）。

3. 高级类特性

3.1 数据类的威力

Kotlin的数据类（data class）可以自动生成：

equals()/hashCode()
toString()
componentN()函数
copy()函数

kotlin复制data class User(
    val id: Long,
    val name: String,
    val email: String
)

// 使用示例
val user1 = User(1, "Alice", "alice@example.com")
val user2 = user1.copy(name = "Alice Smith")  // 复制并修改部分属性

注意：数据类的主构造函数必须至少有一个参数，且所有参数必须标记为val或var。

3.2 密封类与枚举的对比

密封类（sealed class）是枚举的增强版：

kotlin复制sealed class Result<out T> {
    data class Success<out T>(val data: T) : Result<T>()
    data class Error(val exception: Exception) : Result<Nothing>()
    object Loading : Result<Nothing>()
}

// 使用when表达式处理所有可能情况
fun handleResult(result: Result<String>) {
    when(result) {
        is Result.Success -> println(result.data)
        is Result.Error -> println(result.exception)
        Result.Loading -> println("Loading...")
    }
}

实际项目中的应用场景：

API请求结果处理
状态管理
复杂业务逻辑分支

3.3 伴生对象与静态成员

Kotlin没有static关键字，而是使用伴生对象：

kotlin复制class DatabaseClient {
    companion object {
        private const val MAX_CONNECTIONS = 10
        
        fun create(): DatabaseClient {
            return DatabaseClient()
        }
    }
}

// 调用方式
val client = DatabaseClient.create()

伴生对象的特点：

一个类只能有一个伴生对象
可以继承类和实现接口
可以通过@JvmStatic注解生成真正的静态方法

4. 属性与委托

4.1 自定义Getter/Setter

Kotlin属性背后是字段+访问器的组合：

kotlin复制class Person(name: String) {
    var name: String = name
        get() = field.capitalize()
        set(value) {
            field = value.trim()
        }
    
    var age: Int = 0
        private set  // 只能在类内部修改
}

我在项目中常用的模式：

对字符串属性自动trim()
对集合属性返回不可变副本
对数值属性进行范围检查

4.2 属性委托的妙用

Kotlin标准库提供了几种有用的属性委托：

kotlin复制class Example {
    var observableProperty: String by Delegates.observable("<none>") { 
        prop, old, new ->
        println("$old -> $new")
    }
    
    val lazyValue: String by lazy {
        println("computed!")
        "Hello"
    }
}

自定义属性委托：

kotlin复制class PreferenceDelegate<T>(
    private val context: Context,
    private val key: String,
    private val defaultValue: T
) : ReadWriteProperty<Any?, T> {
    // 实现getValue和setValue
}

// 使用示例
class Settings(context: Context) {
    var darkMode by PreferenceDelegate(context, "dark_mode", false)
}

5. 常见问题与解决方案

5.1 初始化顺序导致的NPE

kotlin复制class User {
    val name: String
    val description: String = "User: $name"  // 错误！name还未初始化
    
    constructor(name: String) {
        this.name = name
    }
}

解决方案：

使用主构造函数
将依赖其他属性的初始化放在init块中
使用lazy委托

5.2 数据类继承问题

kotlin复制open class Entity(val id: Long)
data class User(val name: String) : Entity(0)  // 不会生成equals/hashCode考虑父类属性

解决方案：

避免数据类继承
使用组合代替继承
手动实现equals/hashCode

5.3 伴生对象与Java互操作

Java代码调用Kotlin伴生对象成员：

java复制// Kotlin
class Foo {
    companion object {
        fun bar() {}
    }
}

// Java调用
Foo.Companion.bar();  // 默认方式
Foo.bar();            // 需要@JvmStatic注解

最佳实践：

对需要Java调用的方法添加@JvmStatic
考虑使用顶层函数代替伴生对象

6. 性能优化技巧

6.1 内联类（Inline Classes）

Kotlin 1.3引入的内联类可以减少包装类的开销：

kotlin复制@JvmInline
value class Password(private val s: String)

// 运行时会被当作String处理，但编译时是独立类型

使用场景：

类型安全的ID（UserId vs OrderId）
有单位的值（Meters vs Seconds）
需要包装基本类型的场景

6.2 对象池与重用

对于频繁创建的对象，可以考虑对象池：

kotlin复制object ParserPool {
    private val pool = mutableListOf<JsonParser>()
    
    fun acquire(): JsonParser {
        return pool.removeLastOrNull() ?: JsonParser()
    }
    
    fun release(parser: JsonParser) {
        pool.add(parser)
    }
}

6.3 避免不必要的委托

属性委托虽然方便，但会引入额外开销：

kotlin复制// 不推荐 - 每个属性都会创建委托实例
class User {
    var name by Delegates.observable("") { _, _, _ -> }
    var age by Delegates.observable(0) { _, _, _ -> }
}

// 推荐 - 手动实现观察逻辑
class User {
    var name: String = ""
        set(value) {
            field = value
            onPropertyChanged()
        }
    
    private fun onPropertyChanged() {
        // 统一处理变更逻辑
    }
}