接口

Kotlin 的接口与 Java 8 类似，既包含抽象方法的声明，也包含实现。与抽象类不同的是，接口无法保存状态。它可以有属性但必须声明为抽象或提供访问器实现。

使用关键字 interface 来定义接口

1. interface MyInterface {
2. fun bar()
3. fun foo() {
4. // 可选的方法体
5. }
6. }

实现接口

一个类或者对象可以实现一个或多个接口。

1. class Child : MyInterface {
2. override fun bar() {
3. // 方法体
4. }
5. }

接口中的属性

你可以在接口中定义属性。在接口中声明的属性要么是抽象的，要么提供访问器的实现。在接口中声明的属性不能有幕后字段（backing field），因此接口中声明的访问器不能引用它们。

1. interface MyInterface {
2. val prop: Int // 抽象的

4. val propertyWithImplementation: String
5. get() = "foo"

7. fun foo() {
8. print(prop)
9. }
10. }

12. class Child : MyInterface {
13. override val prop: Int = 29
14. }

接口继承

一个接口可以从其他接口派生，从而既提供基类型成员的实现也声明新的函数与属性。很自然地，实现这样接口的类只需定义所缺少的实现：

1. interface Named {
2. val name: String
3. }

5. interface Person : Named {
6. val firstName: String
7. val lastName: String

9. override val name: String get() = "$firstName $lastName"
10. }

12. data class Employee(
13. // 不必实现“name”
14. override val firstName: String,
15. override val lastName: String,
16. val position: Position
17. ) : Person

解决覆盖冲突

实现多个接口时，可能会遇到同一方法继承多个实现的问题。例如

1. interface A {
2. fun foo() { print("A") }
3. fun bar()
4. }

6. interface B {
7. fun foo() { print("B") }
8. fun bar() { print("bar") }
9. }

11. class C : A {
12. override fun bar() { print("bar") }
13. }

15. class D : A, B {
16. override fun foo() {
17. super<A>.foo()
18. super<B>.foo()
19. }

21. override fun bar() {
22. super<B>.bar()
23. }
24. }

上例中，接口 A 和 B 都定义了方法 foo() 和 bar()。 两者都实现了 foo(), 但是只有 B 实现了 bar() (bar() 在 A 中没有标记为抽象，因为没有方法体时默认为抽象）。因为 C 是一个实现了 A 的具体类，所以必须要重写 bar() 并实现这个抽象方法。

然而，如果我们从 A 和 B 派生 D，我们需要实现我们从多个接口继承的所有方法，并指明 D 应该如何实现它们。这一规则既适用于继承单个实现（bar()）的方法也适用于继承多个实现（foo()）的方法。

原文: <https://hltj.gitbooks.io/kotlin-reference-chinese/content/txt/interfaces.html>