kotlin-3 - 技术栈

太棒了！现在让我们进入 Kotlin 最精彩的部分------面向对象编程和高级特性。这一部分将彻底改变你对编程的认知。

Kotlin 面向对象编程：重新定义代码组织方式

十四、类与对象：简洁的开始

Kotlin 中的类定义极其简洁，告别了 Java 的样板代码。

javascript 复制代码

// 最简单的类定义
class Person

// 带主构造函数的类
class Person constructor(firstName: String) { /*...*/ }

// 主构造函数可以省略 constructor 关键字
class Person(firstName: String) {
    // 属性直接在类体中声明
    var firstName: String = firstName
    var lastName: String = ""
    var age: Int = 0
}

// 更简洁的写法：在主构造函数中直接声明属性
class Person(
    val firstName: String,  // 只读属性
    var lastName: String,   // 可变属性
    var age: Int = 0        // 带默认值的参数
) {
    // 类体
}

使用类：

ini 复制代码

val person = Person("张", "三", 25)
println(person.firstName)  // 输出：张
person.age = 26            // 可以修改
// person.firstName = "李" // 错误！firstName 是 val

十五、数据类（Data Class）：自动生成样板代码

这是 Kotlin 的"魔法"特性之一，专门用于存储数据。

kotlin 复制代码

// 数据类定义 - 一行代码搞定！
data class User(
    val id: Int,
    val name: String,
    val email: String
)

// 自动获得以下功能：
val user1 = User(1, "Alice", "alice@example.com")
val user2 = User(1, "Alice", "alice@example.com")

// 1. 自动实现 toString()
println(user1) // 输出：User(id=1, name=Alice, email=alice@example.com)

// 2. 自动实现 equals() 和 hashCode()
println(user1 == user2) // 输出：true（比较内容，不是引用）

// 3. 自动实现 copy() 函数
val user3 = user1.copy(name = "Alice Smith")
println(user3) // 输出：User(id=1, name=Alice Smith, email=alice@example.com)

// 4. 自动实现 componentN() 函数（用于解构）
val (id, name, email) = user1
println("ID: $id, Name: $name") // 输出：ID: 1, Name: Alice

对比 Java： 在 Java 中需要手动编写 getter/setter、equals()、hashCode()、toString() 等大量样板代码。

十六、对象表达式与对象声明：替代匿名类和单例

对象表达式（匿名对象）

kotlin 复制代码

// 类似 Java 的匿名内部类，但更强大
interface ClickListener {
    fun onClick()
}

val button = object : ClickListener {
    override fun onClick() {
        println("Button clicked!")
    }
}

button.onClick()

对象声明（单例模式）

kotlin 复制代码

// 使用 object 关键字创建单例
object DatabaseManager {
    private var connectionCount = 0

    fun connect() {
        connectionCount++
        println("Connected! Total connections: $connectionCount")
    }

    fun getConnectionCount(): Int = connectionCount
}

// 直接通过类名调用，不需要实例化
DatabaseManager.connect() // 输出：Connected! Total connections: 1
DatabaseManager.connect() // 输出：Connected! Total connections: 2

十七、伴生对象（Companion Object）：替代静态成员

Kotlin 没有 static关键字，使用伴生对象实现类似功能。

kotlin 复制代码

class MyClass {
    companion object {
        const val MAX_COUNT = 100  // 类似静态常量
        
        fun create(): MyClass {    // 类似静态工厂方法
            return MyClass()
        }
        
        @JvmStatic  // 如果需要 Java 互操作
        fun staticMethod() {
            println("This can be called from Java as static method")
        }
    }
    
    fun instanceMethod() {
        println("This is an instance method")
    }
}

// 使用方式
println(MyClass.MAX_COUNT)  // 直接通过类名访问
val obj = MyClass.create()   // 直接通过类名调用

十八、密封类（Sealed Class）：受限的类层次结构

密封类用于表示受限的类继承结构，在 when表达式中特别有用。

kotlin 复制代码

// 定义密封类
sealed class Result<out T> {
    data class Success<T>(val data: T) : Result<T>()
    data class Error(val message: String) : Result<Nothing>()
    object Loading : Result<Nothing>()
}

// 使用密封类 - when 表达式会检查是否覆盖所有情况
fun handleResult(result: Result<String>) {
    when (result) {
        is Result.Success -> println("Success: ${result.data}")
        is Result.Error -> println("Error: ${result.message}")
        Result.Loading -> println("Loading...")
        // 不需要 else 分支，因为所有情况都已覆盖
    }
}

val successResult = Result.Success("Data loaded")
val errorResult = Result.Error("Network error")

handleResult(successResult) // 输出：Success: Data loaded
handleResult(errorResult)   // 输出：Error: Network error

十九、扩展函数实战：为现有类添加超能力

让我们看一些实用的扩展函数例子：

kotlin 复制代码

// 为 String 类添加扩展
fun String.isEmail(): Boolean {
    return contains("@") && contains(".")
}

fun String.capitalizeWords(): String {
    return split(" ").joinToString(" ") { it.replaceFirstChar { char -> char.uppercase() } }
}

// 为 List 添加扩展
fun <T> List<T>.second(): T = this[1]
fun <T> List<T>.randomOrNull(): T? = if (isEmpty()) null else this.random()

// 使用扩展函数
println("test@example.com".isEmail())        // 输出：true
println("hello world".capitalizeWords())      // 输出：Hello World

val list = listOf("first", "second", "third")
println(list.second())                       // 输出：second
println(emptyList<String>().randomOrNull())  // 输出：null

二十、属性委托：强大的属性管理

属性委托是 Kotlin 的高级特性，可以简化代码。

lazy 委托：延迟初始化

scss 复制代码

class ExpensiveObject {
    init {
        println("正在创建昂贵的对象...")
    }
}

class MyClass {
    // 只有第一次访问时才会创建
    val expensiveObject: ExpensiveObject by lazy {
        println("第一次访问，开始初始化")
        ExpensiveObject()
    }
}

val myClass = MyClass()
println("对象已创建，但昂贵对象还未初始化")
println(myClass.expensiveObject)  // 这里才会真正初始化
println(myClass.expensiveObject)  // 直接使用已初始化的对象

observable 委托：属性变化监听

kotlin 复制代码

import kotlin.properties.Delegates

class User {
    var name: String by Delegates.observable("未命名") { property, oldValue, newValue ->
        println("属性 ${property.name} 从 '$oldValue' 变为 '$newValue'")
    }
}

val user = User()
user.name = "Alice"  // 输出：属性 name 从 '未命名' 变为 'Alice'
user.name = "Bob"    // 输出：属性 name 从 'Alice' 变为 'Bob'

二十一、空安全深度探索：安全调用链

当处理复杂对象时，安全调用操作符特别有用。

kotlin 复制代码

data class Address(val street: String?, val city: String)
data class Company(val name: String, val address: Address?)
data class Employee(val name: String, val company: Company?)

// 复杂的嵌套对象
val employee: Employee? = Employee(
    "Alice", 
    Company("Tech Corp", Address("Main St", "Beijing"))
)

// 传统方式（繁琐）
val city1 = if (employee != null) {
    if (employee.company != null) {
        if (employee.company.address != null) {
            employee.company.address.city
        } else null
    } else null
} else null

// Kotlin 安全调用链（优雅！）
val city2 = employee?.company?.address?.city

println(city2) // 输出：Beijing

// 如果中间有任何环节为 null，整个表达式返回 null
val employee2: Employee? = Employee("Bob", null)
val city3 = employee2?.company?.address?.city
println(city3) // 输出：null

实战项目：构建一个简单的任务管理系统

kotlin 复制代码

// 定义数据模型
sealed class TaskPriority {
    object Low : TaskPriority()
    object Normal : TaskPriority()
    object High : TaskPriority()
}

data class Task(
    val id: Int,
    val title: String,
    val description: String,
    val priority: TaskPriority,
    val isCompleted: Boolean = false
) {
    // 扩展函数：获取优先级颜色
    fun getPriorityColor(): String = when (priority) {
        TaskPriority.Low -> "绿色"
        TaskPriority.Normal -> "黄色"
        TaskPriority.High -> "红色"
    }
}

// 任务管理器（单例）
object TaskManager {
    private val tasks = mutableListOf<Task>()
    private var nextId = 1
    
    fun addTask(title: String, description: String, priority: TaskPriority): Task {
        val task = Task(nextId++, title, description, priority)
        tasks.add(task)
        return task
    }
    
    fun completeTask(taskId: Int): Boolean {
        val task = tasks.find { it.id == taskId }
        return if (task != null) {
            tasks.replaceAll { if (it.id == taskId) it.copy(isCompleted = true) else it }
            true
        } else {
            false
        }
    }
    
    fun getHighPriorityTasks(): List<Task> {
        return tasks.filter { it.priority is TaskPriority.High && !it.isCompleted }
    }
    
    fun getTasksByPriority(priority: TaskPriority): List<Task> {
        return tasks.filter { it.priority == priority }
    }
}

// 使用任务管理系统
fun main() {
    // 添加任务
    val task1 = TaskManager.addTask("学习 Kotlin", "掌握 Kotlin 高级特性", TaskPriority.High)
    val task2 = TaskManager.addTask("写博客", "分享 Kotlin 学习心得", TaskPriority.Normal)
    
    println("高优先级任务：")
    TaskManager.getHighPriorityTasks().forEach { task ->
        println("${task.title} - 优先级：${task.getPriorityColor()}")
    }
    
    // 完成任务
    TaskManager.completeTask(task1.id)
    println("任务1完成状态：${TaskManager.getHighPriorityTasks().isEmpty()}")
}

下一步学习方向

你现在已经掌握了 Kotlin 的核心高级特性！接下来可以探索：

协程（Coroutines） ：异步编程的现代解决方案
类型安全的构建器（Type-safe builders） ：创建 DSL
反射（Reflection） ：运行时检查代码结构
多平台项目（KMP） ：用 Kotlin 开发 iOS、Web、桌面应用

Kotlin 的世界非常广阔，这些高级特性将让你写出更加优雅、安全、高效的代码。尝试用这些特性重构你之前的项目，你会发现编程可以如此愉快！