Kotlin接口

Kotlin接口

介绍

Kotlin接口（Interface）是一种定义抽象行为的契约，它允许类通过实现（implement）接口来承诺提供某些功能。与抽象类不同，Kotlin接口不能保存状态（即不能有字段），但可以包含抽象方法、默认实现方法以及属性（必须是抽象的或有访问器实现）。接口在Kotlin中通过interface关键字定义，是实现多继承和代码复用的重要工具。

接口的核心特点：

• 定义方法签名或默认实现
• 支持多继承（一个类可实现多个接口）
• 可包含抽象属性和带有实现的属性
• 在Kotlin 1.4+中支持SAM（单一抽象方法）转换

基本语法

接口定义的基本语法结构：

interface MyInterface {
    fun abstractMethod()    // 抽象方法（无实现）
    fun methodWithDefaultImpl() {  // 带默认实现的方法
        println("Default implementation")
    }
    val abstractProperty: String  // 抽象属性
    val propertyWithGetter: String  // 带getter的属性
        get() = "Default value"
}

实现接口

类通过:符号实现接口，多个接口用逗号分隔：

class MyClass : MyInterface {
    override fun abstractMethod() {
        println("Implemented abstract method")
    }
    
    override val abstractProperty: String
        get() = "Implemented property"
}

// 使用
fun main() {
    val obj = MyClass()
    obj.abstractMethod()  // 输出: Implemented abstract method
    println(obj.abstractProperty)  // 输出: Implemented property
    obj.methodWithDefaultImpl()  // 输出: Default implementation
}

接口特性详解

1. 多接口实现

Kotlin支持一个类实现多个接口，当不同接口有相同方法时需要显式解决冲突：

interface A {
    fun foo() { println("A") }
}
interface B {
    fun foo() { println("B") }
}
class C : A, B {
    override fun foo() {
        super<A>.foo()  // 显式选择调用A的实现
        super<B>.foo()  // 显式选择调用B的实现
    }
}

2. 属性声明

接口中的属性可以是抽象的或提供访问器实现：

interface User {
    val email: String        // 抽象属性
    val nickname: String     // 带getter的属性
        get() = email.substringBefore('@')
}

class GoogleUser(override val email: String) : User

fun main() {
    val user = GoogleUser("test@gmail.com")
    println(user.nickname)  // 输出: test
}

3. 函数式接口（SAM）

Kotlin 1.4+支持单一抽象方法的接口（类似Java 8的函数式接口）：

fun interface StringProcessor {
    fun process(input: String): String
}

fun main() {
    // SAM转换
    val upperCase = StringProcessor { it.uppercase() }
    println(upperCase.process("hello"))  // 输出: HELLO
}

实际应用案例

1. 回调机制

接口常用于实现回调模式：

interface DownloadListener {
    fun onStart()
    fun onProgress(percent: Int)
    fun onComplete(file: File)
}

class FileDownloader(private val listener: DownloadListener) {
    fun download(url: String) {
        listener.onStart()
        // 模拟下载
        for (i in 1..100) {
            Thread.sleep(50)
            listener.onProgress(i)
        }
        listener.onComplete(File("downloaded_file"))
    }
}

2. 策略模式

接口可以优雅地实现策略模式：

interface SortingStrategy {
    fun sort(items: MutableList<Int>)
}

class BubbleSort : SortingStrategy {
    override fun sort(items: MutableList<Int>) { /* 冒泡排序实现 */ }
}

class QuickSort : SortingStrategy {
    override fun sort(items: MutableList<Int>) { /* 快速排序实现 */ }
}

class Sorter(private val strategy: SortingStrategy) {
    fun sort(items: MutableList<Int>) = strategy.sort(items)
}

接口 vs 抽象类

classDiagram class 接口 { <<interface>> 只能包含抽象成员 可以有默认实现 不能保存状态 支持多继承 } class 抽象类 { 可以包含具体成员 可以保存状态 单继承 可以有构造函数 }

主要区别：

• 抽象类可以有构造函数，接口不能
• 抽象类可以保存状态（字段），接口不能
• 类只能单继承抽象类，但可实现多个接口
• 接口更适合定义行为契约，抽象类更适合代码复用

高级特性

1. 接口委托

Kotlin支持通过by关键字将接口实现委托给其他对象：

interface Database {
    fun save(data: String)
}

class RealDatabase : Database {
    override fun save(data: String) { /* 实际数据库操作 */ }
}

class LoggerDatabase(private val db: Database) : Database by db {
    override fun save(data: String) {
        println("Log: saving $data")
        db.save(data)
    }
}

2. 接口中的伴生对象

接口可以包含伴生对象来定义静态成员：

interface Factory<T> {
    companion object {
        fun <T> createDefault(): T { /* 默认实现 */ }
    }
}

最佳实践

1. 优先使用接口而非抽象类来定义契约 2. 保持接口小巧专注（单一职责原则） 3. 使用默认实现减少实现类的样板代码 4. 考虑使用SAM接口替代高阶函数提升性能 5. 使用接口委托模式避免重复实现

总结

Kotlin接口是定义抽象行为的强大工具，支持：

• 方法声明与默认实现
• 属性声明
• 多继承
• SAM转换
• 委托模式

通过合理使用接口，可以构建灵活、可维护的面向对象系统，实现松耦合和高度可扩展的代码结构。