接口

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

使用关键字 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 // 抽象的
  3. val propertyWithImplementation: String
  4. get() = "foo"
  5. fun foo() {
  6. print(prop)
  7. }
  8. }
  9. class Child : MyInterface {
  10. override val prop: Int = 29
  11. }

接口继承

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

  1. interface Named {
  2. val name: String
  3. }
  4. interface Person : Named {
  5. val firstName: String
  6. val lastName: String
  7. override val name: String get() = "$firstName $lastName"
  8. }
  9. data class Employee(
  10. // 不必实现“name”
  11. override val firstName: String,
  12. override val lastName: String,
  13. val position: Position
  14. ) : Person

解决覆盖冲突

实现多个接口时,可能会遇到同一方法继承多个实现的问题:

  1. interface A {
  2. fun foo() { print("A") }
  3. fun bar()
  4. }
  5. interface B {
  6. fun foo() { print("B") }
  7. fun bar() { print("bar") }
  8. }
  9. class C : A {
  10. override fun bar() { print("bar") }
  11. }
  12. class D : A, B {
  13. override fun foo() {
  14. super<A>.foo()
  15. super<B>.foo()
  16. }
  17. override fun bar() {
  18. super<B>.bar()
  19. }
  20. }

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

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