编辑“︁Kotlin接口”︁（章节）

= Kotlin接口 =

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

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

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

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

== 实现接口 ==
类通过<code>:</code>符号实现接口，多个接口用逗号分隔：

<syntaxhighlight lang="kotlin">
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
}
</syntaxhighlight>

== 接口特性详解 ==

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

<syntaxhighlight lang="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的实现
    }
}
</syntaxhighlight>

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

<syntaxhighlight lang="kotlin">
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
}
</syntaxhighlight>

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

<syntaxhighlight lang="kotlin">
fun interface StringProcessor {
    fun process(input: String): String
}

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

== 实际应用案例 ==

=== 1. 回调机制 ===
接口常用于实现回调模式：

<syntaxhighlight lang="kotlin">
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"))
    }
}
</syntaxhighlight>

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

<syntaxhighlight lang="kotlin">
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)
}
</syntaxhighlight>

== 接口 vs 抽象类 ==

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

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

== 高级特性 ==

=== 1. 接口委托 ===
Kotlin支持通过<code>by</code>关键字将接口实现委托给其他对象：

<syntaxhighlight lang="kotlin">
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)
    }
}
</syntaxhighlight>

=== 2. 接口中的伴生对象 ===
接口可以包含伴生对象来定义静态成员：

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

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

== 总结 ==
Kotlin接口是定义抽象行为的强大工具，支持：
* 方法声明与默认实现
* 属性声明
* 多继承
* SAM转换
* 委托模式

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

[[Category:编程语言]]
[[Category:Kotlin]]
[[Category:Kotlin面向对象编程]]