21.Kotlin 接口：接口 (Interface)：抽象方法、属性与默认实现

希望帮你在Kotlin进阶路上少走弯路，在技术上稳步提升。当然，由于个人知识储备有限，笔记中难免存在疏漏或表述不当的地方，也非常欢迎大家提出宝贵意见，一起交流进步。 ------ Android_小雨

整体目录：Kotlin 进阶不迷路：41 个核心知识点，构建完整知识体系

一、前言

Kotlin 官方对接口的完整定义（逐句拆解）

Kotlin 官方文档中对接口的核心定义及关键描述如下（整合官方核心表述，保持原文语义）：

Interfaces in Kotlin are similar to Java 8 interfaces. They can contain abstract methods, as well as method implementations. What makes them different from abstract classes is that interfaces cannot store state. They can have properties but these need to be abstract or provide accessor implementations that do not reference a backing field.An interface is defined using the keyword interface.Interfaces can inherit from other interfaces, and a class can implement multiple interfaces.

官方强调的 5 个核心点（记住这 5 条就掌握了接口本质）：

1. 接口本质是「行为契约」，支持抽象方法 + 默认实现方法（类似 Java 8 接口）
2. 接口不能存储状态：可声明属性，但必须是抽象属性（无初始值），或提供不依赖后端字段（backing field）的访问器（getter/setter）实现
3. 接口用 interface 关键字定义，语法简洁无构造器（不能实例化）
4. 支持多继承 / 多实现：接口可继承多个其他接口，一个类可实现多个接口
5. 与抽象类的核心区别：无状态、支持多实现，不参与类的单继承体系

一句话总结：

接口是无状态的行为契约，通过抽象方法定义必须实现的能力，通过默认实现复用通用逻辑，支持多实现以灵活扩展类的能力集。

1.1 接口的核心定位

接口（Interface）是面向对象编程中"契约"精神的体现。它定义了一组行为规范 （Can-Do），而不关心具体的实现细节。通过接口，我们可以实现多态，将类的定义与具体的行为解耦，使系统架构更加灵活。

1.2 Kotlin 接口的设计优势

相比于传统的 Java 接口，Kotlin 接口更加强大和灵活：

• 默认实现：允许接口提供方法的默认逻辑，减少样板代码。
• 抽象属性：接口不仅能定义行为，还能规范"状态"的访问方式（尽管不能存储状态）。
• 多重继承支持：完善的冲突解决机制，让类可以安全地实现多个接口。

1.3 核心疑问：Kotlin 接口与 Java 接口、抽象类有何本质区别？

"为什么 Kotlin 接口里可以写方法体？""接口里定义的属性和类里的属性是一回事吗？"

本质区别在于：接口不能保存状态（State），而抽象类可以。 即使 Kotlin 接口看起来像类，但它永远无法直接存储值（没有 Backing Field）。

1.4 本文核心内容预告

本文将按照以下路径深入剖析：

1. 基础定义：语法与规则。
2. 三大核心：抽象方法、抽象属性、默认实现。
3. 实战场景：多实现与冲突解决。
4. 对比辨析：vs Java 接口 & 抽象类。

二、接口基础：定义与语法规范

2.1 基本语法

使用 interface 关键字定义，接口没有构造函数（因为它是无状态的）。

interface MyInterface {
    fun bar()
    fun foo() {
        // 可选的方法体
    }
}

2.2 核心规则

• 可以包含：抽象方法、默认方法（带方法体）、抽象属性。
• 不能包含：状态字段（Backing Fields）、构造函数。
• 实例化：接口不能直接实例化，必须通过类实现或匿名内部类（object expression）创建。

2.3 简单示例

interface Displayable {
    fun show() // 抽象方法
}

2.4 关键特性

• 多实现：一个类可以实现多个接口（解决单继承限制）。
• 接口继承：接口可以继承其他接口。

三、接口核心组成（一）：抽象方法

3.1 定义语法

在接口中直接声明方法，如果没有提供方法体 { ... }，它默认就是 abstract 的（无需显式写 abstract 关键字）。

interface Clickable {
    fun onClick() // 这是一个抽象方法
}

3.2 核心要求

实现该接口的非抽象类 ，必须重写所有的抽象方法。

3.3 方法规则与修正

• 接口方法默认是 open 的。
• 修正点 ：在 Java 中实现接口方法不需要 override 关键字，但在 Kotlin 中，实现接口的抽象方法必须显式加上 override 关键字。这是为了防止意外的方法签名冲突。

3.4 示例

class Button : Clickable {
    // 必须加 override
    override fun onClick() {
        println("Button clicked!")
    }
}

四、接口核心组成（二）：抽象属性

4.1 什么是接口抽象属性？

这是 Kotlin 接口的一大特色。接口可以定义属性，但这不代表接口有内存空间来存储这个值。它只是规定实现类必须提供一个"获取该属性值"的方式（即 getter/setter 契约）。

4.2 定义语法

interface Named {
    val name: String // 抽象属性，没有初始化值
}

4.3 实现规则

4.3.1 实现类重写

实现类可以使用主构造函数参数直接重写，也可以自定义 getter。

// 方式 A：在主构造函数中重写（最常用）
class User(override val name: String) : Named

// 方式 B：使用自定义 getter
class Computer : Named {
    override val name: String
        get() = "System_PC" // 动态计算
}

4.3.2 var 属性要求

如果接口定义的是 var（可变属性），实现类必须同时提供 getter 和 setter。

4.4 示例

interface Renameable {
    var nickName: String
}

class Player : Renameable {
    // 必须有一个真实字段来存储状态
    private var _name = "Guest"

    override var nickName: String
        get() = _name
        set(value) { _name = value }
}

五、接口核心组成（三）：默认实现（Kotlin 特有）

5.1 定义语法

如果在接口方法或属性中提供了具体逻辑（方法体或 getter），它就变成了默认实现。

5.2 核心价值

• 非强制重写：实现类可以直接复用默认逻辑。
• 扩展性 ：在旧接口中新增带有默认实现的方法，不会破坏已有的实现类代码（二进制兼容性除外，但源码级兼容）。

5.3 方法默认实现

5.3.1 示例

interface Logger {
    // 默认实现
    fun log(msg: String) {
        println("Log: $msg")
    }
}

class ConsoleLogger : Logger {
    // 不需要重写 log 方法，直接拥有该功能
}

5.3.2 注意点

默认方法内部可以调用接口的其他方法（包括抽象方法），这构成了模板方法模式的基础。

5.4 属性默认实现

5.4.1 语法

接口属性不能有初始值（val x = 1 ❌），但可以有默认的 getter。

interface HasId {
    val id: Int
    // 属性的默认实现（必须通过 getter）
    val idString: String
        get() = "ID_$id" // 依赖于抽象属性 id
}

5.5 重写默认实现

如果默认逻辑不符合需求，实现类依然可以通过 override 覆盖它。

六、接口的继承与多实现

6.1 接口继承接口

接口之间可以继承，子接口可以继承父接口的方法，也可以覆盖父接口的默认实现。

interface AdvancedClickable : Clickable {
    fun onLongClick() // 新增抽象方法
}

6.2 类多实现接口与冲突解决

6.2.1 默认实现冲突

当一个类实现了两个接口（A 和 B），且这两个接口都有一个同名的默认方法 foo() 时，编译器会报错，强制要求类重写 foo() 以消除歧义。

6.2.2 示例：解决冲突

interface A {
    fun foo() { println("A") }
}

interface B {
    fun foo() { println("B") }
}

class C : A, B {
    // 必须显式重写，否则编译报错
    override fun foo() {
        // 可以选择调用 A 的，也可以调用 B 的，或者写全新的逻辑
        super<A>.foo()
        super<B>.foo()
    }
}

七、实用场景与实战示例

7.1 行为规范定义

核心价值：定义"能做什么"的通用行为标准，不关心"怎么做"，实现跨类别的行为统一约束。

这种场景下，接口仅提供抽象方法或属性，作为不同类的"行为契约"。典型案例是Kotlin标准库中的Comparable（定义"可比较"行为）、Runnable（定义"可执行"行为）。

// 定义"可打印"行为规范（仅约束能做什么）
interface Printable {
    // 抽象方法：仅定义签名，无实现
    fun printContent(): String
}

// 不同类实现该规范，各自实现"怎么做"
class Article(val title: String) : Printable {
    override fun printContent(): String {
        return "文章：$title"
    }
}

class Picture(val name: String) : Printable {
    override fun printContent(): String {
        return "图片：$name"
    }
}

fun main() {
    val items = listOf(Article("Kotlin接口详解"), Picture("风景图"))
    items.forEach { println(it.printContent()) }
    // 输出：文章：Kotlin接口详解；图片：风景图
}

7.2 多态场景

核心价值：以接口为参数/返回值，屏蔽实现类的具体差异，实现"同一操作适配不同对象"，降低代码耦合。

多态的核心是"面向接口编程"------调用方只需依赖接口定义的行为，无需关心具体是哪个实现类，新增实现类时无需修改调用逻辑。

// 定义"可展示"行为接口
interface Displayable {
    fun show()
}

// 实现类1：按钮
class Button(val text: String) : Displayable {
    override fun show() {
        println("显示按钮：$text")
    }
}

// 实现类2：图片
class Image(val url: String) : Displayable {
    override fun show() {
        println("显示图片：$url")
    }
}

// 多态核心：参数为接口类型，适配所有实现类
fun handleDisplay(item: Displayable) {
    item.show() // 不关心是Button还是Image，只调用接口方法
}

fun main() {
    val button = Button("提交")
    val image = Image("https://example.com/pic.jpg")
    handleDisplay(button)  // 输出：显示按钮：提交
    handleDisplay(image)   // 输出：显示图片：https://example.com/pic.jpg
    // 新增实现类（如Text），直接调用handleDisplay即可，无需修改该函数
}

7.3 接口默认实现简化扩展

核心价值：给接口方法提供默认逻辑，实现类仅需重写"个性化"方法，减少重复代码，尤其适合框架开发。

框架开发中，常需定义大量扩展点。若全为抽象方法，实现类需重写所有方法，冗余且不灵活；默认实现可提供"基础操作"或"空操作"，用户按需重写。

// 框架级接口：提供默认实现，简化扩展
interface DataProcessor {
    // 核心抽象方法：必须重写（业务核心）
    fun processData(data: String): String

    // 默认实现方法1：基础操作，可选重写
    fun validateData(data: String): Boolean {
        return data.isNotBlank() // 基础校验：非空
    }

    // 默认实现方法2：空操作，可选重写
    fun afterProcess() {
        // 框架默认无操作，用户可重写实现后续逻辑
    }
}

// 业务实现类：仅重写核心和需要个性化的方法
class UserDataProcessor : DataProcessor {
    // 必须重写核心方法
    override fun processData(data: String): String {
        return "处理用户数据：$data"
    }

    // 仅重写需要个性化的校验逻辑，其他用默认实现
    override fun validateData(data: String): Boolean {
        return super.validateData(data) && data.length > 5 // 增强校验
    }
}

fun main() {
    val processor = UserDataProcessor()
    if (processor.validateData("user123")) {
        println(processor.processData("user123")) // 输出：处理用户数据：user123
        processor.afterProcess() // 无输出（用默认空实现）
    }
}

7.4 完整实战示例

以"可移动对象"为例，整合接口的抽象属性、抽象方法、默认实现，展示接口在实际业务中的完整应用。

/**
 * 可移动对象接口
 * 包含：抽象属性（坐标x/y）、默认实现方法（移动逻辑）
 */
interface Movable {
    // 抽象属性：要求实现类必须定义并初始化
    var x: Int
    var y: Int

    // 带默认实现的方法：移动逻辑，实现类可重写
    fun move(dx: Int, dy: Int) {
        x += dx
        y += dy
        logMove() // 调用接口内部的辅助方法
    }

    // 接口内部辅助方法（默认实现）
    fun logMove() {
        println("已移动到坐标：($x, $y)")
    }
}

// 实现类1：汽车（使用默认移动逻辑）
class Car(override var x: Int, override var y: Int, val name: String) : Movable

// 实现类2：飞机（重写移动逻辑，自定义行为）
class Plane(override var x: Int, override var y: Int, val speed: Int) : Movable {
    // 重写默认方法：飞机移动速度更快，附加速度信息
    override fun move(dx: Int, dy: Int) {
        val realDx = dx * speed
        val realDy = dy * speed
        x += realDx
        y += realDy
        logMove()
    }

    // 重写日志方法：附加飞机名称
    override fun logMove() {
        println("飞机${name ?: "未知"}已移动到坐标：($x, $y)")
    }
}

fun main() {
    // 汽车：使用接口默认移动逻辑
    val car = Car(0, 0, "家用轿车")
    car.move(10, 20) // 输出：已移动到坐标：(10, 20)

    // 飞机：使用自定义移动逻辑
    val plane = Plane(0, 0, 5)
    plane.name = "波音747"
    plane.move(10, 20) // 输出：飞机波音747已移动到坐标：(50, 100)
}

实战要点：接口通过"抽象属性约束状态""默认方法提供基础逻辑"，实现类可灵活选择复用或重写，既保证了行为一致性，又保留了个性化扩展空间。

八、与抽象类、Java 接口的核心区别

8.1 Kotlin 接口 vs 抽象类

对比维度	Kotlin 接口 (Interface)	抽象类 (Abstract Class)
状态存储	无 (不能有 Backing Fields)	有 (可以定义 val/var name = "Bob")
构造函数	无	有 (主/次构造函数)
多继承	支持 (多实现)	不支持 (单继承)
核心用途	定义行为规范、解耦、多态	封装共性逻辑、代码复用、状态复用

8.2 Kotlin 接口 vs Java 接口 (Java 8+)

1. 属性支持：Kotlin 接口原生支持抽象属性和属性 getter 默认实现，Java 接口主要是方法。
2. Override 关键字 ：Kotlin 强制要求 override，Java 是可选注解 @Override。
3. 静态成员 ：Java 接口可以直接定义 static 方法；Kotlin 接口通常将相关静态逻辑放在 companion object 中（虽然 JVM 层面可以映射）。

九、使用注意事项与避坑点

9.1 接口不可含状态字段

切记：val prop: Int = 0 在接口中是非法的。接口不能保存数据，只能定义"获取数据的方法"。

9.2 多实现默认方法冲突

遇到 Conflict 报错不要慌，手动 override 并指定 super<T>.method() 即可。

9.3 抽象属性实现要求

实现 var 属性时，千万别忘了 setter。如果是用 get() 实现的，确保它不会返回不一致的状态。

9.4 避免过度设计

不要为了使用接口而使用接口。如果类与类之间有很强的"血缘关系"且需要共享状态，抽象类可能更合适。

9.5 默认实现不可依赖外部状态

接口的默认方法是无状态的，这意味着它只能操作接口内定义的其他属性或方法，无法访问实现类的私有字段，线程安全性需由实现类保证。

十、总结与最佳实践

10.1 核心知识点回顾

• 定义 ：interface 关键字，无构造函数。
• 抽象：方法默认 abstract，属性需重写。
• 实现 ：override 关键字必不可少。
• 默认：方法体即默认实现，属性 getter 即默认实现。

10.2 最佳实践

• 接口隔离原则 ：将大接口拆分为多个小接口（如 Readable, Writable）。
• 默认实现兜底：利用默认方法减少实现类的样板代码，尤其是当接口方法很多时。
• 优先使用接口：在不需要共享状态的情况下，优先使用接口来实现多态，保留类的继承位置（毕竟类是单继承的）。

10.3 选型建议

• 需要 多重继承 能力 -> 接口。
• 需要 定义行为规范 (Can-Do) -> 接口。
• 需要 复用成员变量 (State) -> 抽象类。

十一、全文总结

为了方便记忆，我们将 Kotlin 接口的核心精华总结为以下"1-2-3-4"法则：

1 个核心限制

• 无状态（No State） ：接口绝对不能包含状态字段（Backing Field）。虽然可以定义属性，但那本质上是 getter/setter 方法的声明，不占内存空间。

2 大核心增强（vs Java 7）

1. 抽象属性：接口可以定义属性，强制实现类提供 getter/setter。
2. 默认实现：方法和属性（getter）可以提供默认逻辑，无需强制重写。

3 个关键组成

1. 抽象方法 ：定义行为契约，无方法体，实现类必须 override。
2. 默认方法 ：提供通用逻辑，有方法体，实现类可选 override。
3. 抽象属性：定义状态访问契约，实现类必须提供值的来源。

4 条重要规则

1. Override 强制性 ：实现接口成员必须加 override 关键字。
2. 冲突解决 ：多实现产生同名默认方法冲突时，必须显式重写并指定 super<T>。
3. 无构造函数：接口不能被直接实例化。
4. 多重实现：一个类可以实现多个接口，弥补单继承的不足。