系列文章全部为本人的学习笔记，若有任何不妥之处，随时欢迎拍砖指正。如果你觉得我的文章对你有用，欢迎关注我，我们一起学习进步！
Kotlin学习笔记（1）- 环境配置
Kotlin学习笔记（2）- 空安全
Kotlin学习笔记（3）- 语法
Kotlin学习笔记（4）- 流程控制
Kotlin学习笔记（5）- 类
Kotlin学习笔记（6）- 属性
Kotlin学习笔记（7）- 接口
Kotlin学习笔记（8）- 扩展
Kotlin学习笔记（8）- 扩展（续）
Kotlin学习笔记（9）- 数据类
Kotlin学习笔记（10）- 泛型
Kotlin学习笔记（11）- 内部类和嵌套类
Kotlin学习笔记（12）- 委托
Kotlin学习笔记（13）- 函数式编程
Kotlin学习笔记（14）- lambda

一、接口定义

和java一样，kotlin中的接口也是使用interface关键字。

interface Wing{
    fun fly() 
}

和java不同的是，接口的实现不是使用implement关键字，而是冒号:，和继承一样。所以我认为kotlin中的接口是一种特殊的抽象类。

class InterfaceLesson : Wing{
    override fun fly() {
    }
}

二、方法和属性

kotlin中的接口可以有方法和属性，java中也是，我们来说说他们的不同。

1. java中的属性必须初始化，而且是静态常量。kotlin中的属性默认为abstract，在接口中不能初始化，必须在实现类中进行初始化，并且在初始化时要加override修饰。

   interface Wing{
       var count : Int
   }
   

2. java中的方法必须为抽象，需要在实现类中进行实现。kotlin中的方法可以为抽象，也可以有实现，实现了的方法在具体类中可以不用覆写。（所以更加让我觉得这就是一种特殊的抽象类）

   interface Wing{
       fun fly() {
           Log.d("text", "Wing -> fly") // 这里实现了接口的方法
       }
   }
   class InterfaceLesson : Wing{
       fun test(){
           fly()            //  在具体类中可以不用覆写接口中的实现方法，直接调用
       }
   }
   // 输出
   Wing -> fly
   

三、继承

和java一样，接口可以继承接口，类可以实现多个接口。

有的文章提到kotlin中的接口可以继承open类，但是现在的版本已经不行了，接口只能继承接口

四、多继承重载

我们上面已经说过，kotlin中接口的方法可以实现，并且如果已经在接口中实现，子类中可以不实现。接下来说一些特殊情况：如果子类实现了多个接口，而这些接口中有同名方法的处理。这个在《Kotlin学习笔记（5）- 类》中有所提及，这里多说一些。

1. 如果接口实现了方法，子类中可以进行覆写，同时也可以调用super方法调用接口的实现

   interface Wing{
       fun fly() {
           Log.d("text", "Wing -> fly")
       }
   }
   open class InterfaceLesson : Wing{
       override fun fly() {
           super.fly()
       }
   }
   

2. 如果接口没实现方法，子类必须进行实现，且不能调用super

   interface Wing{
       fun fly() 
   }
   class InterfaceLesson : Wing{
       override fun fly() {
       }
   }
   

3. 如果多个接口有相同的方法，无论接口中是否实现，子类都必须实现该方法。其中，如果两个接口中都没有实现，则子类不能使用super关键字

   interface Foot{
       fun run() 
   }
   
   interface Car{
       fun run() 
   }
   
   class InterfaceLesson : Foot, Car{
       override fun run() {
       }
   }
   

   如果有一个类有实现，则子类可以使用super关键字，且自动调用实现的方法。

   interface Foot{
       fun run()
   }
   
   interface Car{
       fun run() {
           Log.d("text", "Car -> run1")
       }
   }
   
   class InterfaceLesson : Foot, Car{
       override fun run() {
           super.run()
       }
   }
   
   // 输出
   Car -> run1
   

   如果两个接口都实现了该方法，则子类在调用super的时候需要使用尖括号对调用的父方法进行声明。

   interface Foot{
       fun run() {
           Log.d("text", "Foot -> run")
       }
   }
   
   interface Car{
       fun run() {
           Log.d("text", "Car -> run1")
       }
   }
   
   class InterfaceLesson : Foot, Car{
       override fun run() {
           super<Foot>.run()
       }
   }
   
   // 输出
   Foot -> run