接口是类的蓝图(基础框架)。Kotlin接口类似于Java 8中的接口，它包含抽象方法声明以及方法的实现。

定义接口

接口是使用interface关键字来定义的。 例如：

interface MyInterface {
    val id: Int // abstract property  
    fun absMethod()// abstract method  
    fun doSomthing() {
        // optional body  
    }
}

默认情况下，仅在没有方法体(方法只声明未实现)的情况下声明的方法是抽象的。

为什么要使用Kotlin接口？

以下是使用接口的理由：

• 使用接口支持多重继承功能。
• 它可以用来实现松耦合。
• 它用于实现抽象。

一个类只能扩展一个超类但可以实现多个接口。 父类或接口实现的扩展是在子类中使用(:)运算符完成的。

实现接口

在这个例子中，在InterfaceImp类中实现了MyInterface接口。 InterfaceImp类提供了在MyInterface接口中声明的属性id和抽象方法absMethod()的实现。

interface MyInterface  {
    var id: Int            // abstract property
    fun absMethod():String    // abstract method
    fun doSomthing() {
        println("MyInterface做了一些工作")
    }
}
class InterfaceImp : MyInterface {
    override var id: Int = 10010
    override fun absMethod(): String{
        return "实现抽象方法.."
    }
}
fun main(args: Array<String>) {
    val obj = InterfaceImp()
    println("调用覆盖id值，当前 ID = ${obj.id}")
    obj.doSomthing()
    println(obj.absMethod())
}

执行上面示例代码，得到以下结果 -

调用覆盖id值，当前 ID = 10010
MyInterface做了一些工作
实现抽象方法..

实现多个接口

可以在同一个类中实现不同接口的多个抽象方法。 所有抽象方法都必须在子类中实现。 可以从派生类调用其他非抽象的接口方法。

例如，分别使用抽象方法doSomthing()和absMethod()创建两个接口MyInterface1和MyInterface2，然后在派生类MyClass中覆盖这些抽象方法。

interface MyInterface1 {
    fun doSomthing()
}
interface MyInterface2 {
    fun absMethod()
}
class MyClass : MyInterface1, MyInterface2 {
    override fun doSomthing() {
        println("overriding doSomthing() of MyInterface1")
    }

    override fun absMethod() {
        println("overriding absMethod() of MyInterface2")
    }
}
fun main(args: Array<String>) {
    val myClass = MyClass()
    myClass.doSomthing()
    myClass.absMethod()
}

执行上面示例代码，得到以下结果 -

overriding doSomthing() of MyInterface1
overriding absMethod() of MyInterface2

解决具有相同方法的不同接口覆盖冲突

让我们先来看看一个示例，接口MyInterface1和接口MyInterface2都包含相同的非抽象方法。 MyClass类提供了这些接口的实现。 使用MyClass对象调用接口方法时会产生错误。

interface MyInterface1 {
    fun doSomthing(){
        println("overriding doSomthing() of MyInterface1")
    }
}
interface MyInterface2 {
    fun doSomthing(){
        println("overriding doSomthing() of MyInterface2")
    }
}
class MyClass : MyInterface1, MyInterface2 {

}
fun main(args: Array<String>) {
    val myClass = MyClass()
    myClass.doSomthing()
}

执行上面示例代码，得到以下结果 -

Error:(11, 1) Kotlin: Class 'MyClass' must override public open fun doSomthing(): Unit defined in MyInterface1 because it inherits multiple interface methods of it

要解决上述问题，需要指定调用的特定接口方法。看下面的例子。

在下面的示例中，两个接口MyInterface1和MyInterface2分别包含两个抽象方法adsMethod()和absMethod(name：String)以及非抽象方法doSomthing()。 MyClass类实现接口和覆盖抽象方法absMethod()和absMethod(name：String)。 要覆盖非抽象方法doSomthing()，需要使用super关键字指定接口名称为super <interface_name> .methodName()。

示例1

interface MyInterface1 {
    fun doSomthing() {
        println("MyInterface 1 做了一些工作")
    }
    fun absMethod()
}
interface MyInterface2 {
    fun doSomthing(){
        println("MyInterface 2 做了一些工作")
    }
    fun absMethod(name: String)
}
class MyClass : MyInterface1, MyInterface2 {
    override fun doSomthing() {
        super<MyInterface2>.doSomthing()
    }

    override fun absMethod() {
        println("实现了 MyInterface1 的 absMethod() 方法")
    }
    override fun absMethod(n: String) {
        println("实现了 MyInterface1 的 absMethod(name) 方法，名称是：$n")
    }
}
fun main(args: Array<String>) {
    val myClass = MyClass()
    myClass.doSomthing()
    myClass.absMethod()
    myClass.absMethod("Maxsu")
}

执行上面示例代码，得到以下结果 -

MyInterface 2 做了一些工作
实现了 MyInterface1 的 absMethod() 方法
实现了 MyInterface1 的 absMethod(name) 方法，名称是：Maxsu

示例2

interface MyInterface1 {
    fun doSomthing() {
        println("MyInterface1 doSomthing方法执行")
    }
    fun absMethod()
}

interface MyInterface2 {
    fun doSomthing() {
        println("MyInterface2 doSomthing方法执行")
    }
    fun absMethod() {
        println("MyInterface2 absMethod方法执行")
    }

}

class C : MyInterface1 {
    override fun absMethod() {
        println("MyInterface1 absMethod 方法实现")
    }
}

class D : MyInterface1, MyInterface2 {
    override fun doSomthing() {
        super<MyInterface1>.doSomthing()
        super<MyInterface2>.doSomthing()
    }

    override fun absMethod() {
        super<MyInterface2>.absMethod()
    }
}

fun main(args: Array<String>) {
    val d = D()
    val c = C()
    d.doSomthing()
    d.absMethod()
    c.doSomthing()
    c.absMethod()
}

执行上面示例代码，得到以下结果 -

MyInterface1 doSomthing方法执行
MyInterface2 doSomthing方法执行
MyInterface2 absMethod方法执行
MyInterface1 doSomthing方法执行
MyInterface1 absMethod 方法实现