Kotlin之接口

接口

Kotlin 的接口可以既包含抽象方法的声明也包含实现。

关键字 interface 来定义接口

interface MyInterface {
    fun bar()
    fun foo() {
      // 已经实现的方法，子类可以选择性的覆盖
    }
}

接口B

interface MyInterfaceB {
    fun barB()
}

实现接口

实现一个接口

class Child : MyInterface {
    override fun bar() {
        // 实现接口方法体
    }
}

实现两个接口

class Child : MyInterface,MyInterfaceB {
    override fun bar() {
        // 实现接口方法体
    }
    override fun barB() {
		// 实现接口方法体
    }
}

接口中的属性

可以在接口中定义属性，如果没有实现get、set就是抽象的，子类需要实现
**注意：**接口中声明的访问器不能引用 幕后字段field

interface MyInterface {
    val prop: Int // 抽象的
	
	//已实现的属性，子类可以选择性的覆盖
    val propertyWithImplementation: String
        get() = "foo"

    fun foo() {
    	// 已经实现的方法，子类可以选择性的覆盖
        print(prop)
    }
}

class Child : MyInterface {
    override val prop: Int = 29
}

接口继承

一个接口可以从其他接口继承，子类字需要实现未实现的抽象成员

interface Named {
    val name: String
}

interface Person : Named {
    val firstName: String
    val lastName: String
    
    //实现接口Named 的name属性
    override val name: String get() = "$firstName $lastName"
}

data class Employee(
    // 不必实现“name”
    override val firstName: String,
    override val lastName: String,
    val position: Position
) : Person

解决覆盖冲突

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

interface A {
    fun foo() { print("A") }
    fun bar()
}

interface B {
    fun foo() { print("B") }
    fun bar() { print("bar") }
}

class C : A {
	//A bar是抽象的必须重写
    override fun bar() { print("bar") }
}

class D : A, B {
    override fun foo() {
        super<A>.foo()
        super<B>.foo()
    }

    override fun bar() {
    	//super<A>.bar() A bar是抽象无法调用
        super<B>.bar()
    }
}

函数式（SAM）接口

只有一个抽象方法的接口称为函数式接口或 SAM（单一抽象方法）接口。
注意：函数式接口可以有多个非抽象成员，但只能有一个抽象成员。

可以用 fun 修饰符在 Kotlin 中声明一个函数式接口。

fun interface KRunnable {
   fun invoke()
}

SAM 转换

对于函数式接口，可以通过 lambda 表达式实现 SAM 转换，从而使代码更简洁、更有可读性。

如有一下函数式接口

fun interface IntPredicate {
   fun accept(i: Int): Boolean
}

不使用 SAM 转换

// 创建一个类的实例
val isEven = object : IntPredicate {
        override fun accept(i: Int): Boolean {
            return i % 2 == 0
        }
    }

使用SAM转换

// 通过 lambda 表达式创建一个实例
val isEven = IntPredicate { i -> i % 2 == 0 }