Kotlin编程之接口和实现接口

比眉伴天荒 2022-06-15 10:21 479阅读 0赞

**Kotlin编程相关知识点介绍**：

*  [Kotlin编程之使用Intellij IED和了解源文件（.kt）][Kotlin_Intellij IED_.kt]
 *  [Kotlin编程之类的介绍和使用][Kotlin]
 *  [Kotlin编程之类的属性][Kotlin 1]
 *  [Kotlin编程之方法][Kotlin 2]
 *  [Kotlin编程之父类和继承父类][Kotlin 3]

--------------------

本篇概括：

*  **接口介绍**
 *  **实现接口**

## **定义接口**： ##

--------------------

介绍：

> Kotlin 的接口很像 java 8。它们都可以包含抽象方法，以及方法的实现。和抽象类不同的是，接口不能保存状态。可以有属性但必须是抽象的，或者提供访问器的实现。

定义一个接口，包含抽象属性，属性的访问器实现，抽象方法，方法的实现，编写代码如下：

package com.xingen.kotlin
    
    fun main(args: Array<String>) {
        var instance = Test2015526()
        println(instance.property)
        println(instance.propertyIml)
    
        instance.test()
        instance.test1()
    }
    
    class Test2015526 : TestInterface {
        override val property: String get() = "实现类定义接口中属性的实现"
    
        override fun test1() {
            println("在实现类中重写接口方法 ")
        }
    }
    
    /** * 自定义一个接口 */
    interface TestInterface {
        /** * 抽象的属性 */
        val property: String
    
        /** * 访问器（这里指的是属性的get()）的实现，即抽象属性的实现 */
        val propertyIml: String get() = "接口内部定义属性的实现"
    
        /** * 方法的实现 */
        fun test() {
            println("输出自定义的接口方法 ")
        }
    
        /** * 抽象方法 */
        fun test1()
    }

输出结果：

实现类定义接口中属性的实现
    接口内部定义属性的实现
    输出自定义的接口方法 
    在实现类中重写接口方法

**可知**：

*  用关键字`interface`定义接口
 *  一个类可以实现一个或者多个接口
 *  接口中有两种方法（抽象方法和方法的实现），有两种属性（抽象属性和属性访问器的实现）,这与Java有很大的不同。
 *  接口中只有`val`修饰的只读属性，没有`var`修饰的可写属性
 *  实现接口，在类头后面添加`:接口名`
 *  实现接口，必需重写抽象属性和抽象方法，且用`override`修饰。
 *  接口的方法和属性默认`open`修饰的

## 接口和父类存在同名方法的处理方式 ##

--------------------

package com.xingen.kotlin
    
    fun main(str: Array<String>) {
        Test<String>("本类是").test()
    }
    class Test<T> constructor(override var t: T) : BaseTest<T>(t),TestInterface {
        /** * 复写父类中的方法 */
        override fun test() {
    
            println("${t} Test子类 ")
            //调用接口的test()
            super<TestInterface>.test()
            //调用父类的test()
            super<BaseTest>.test()
        }
    }
    /** * 自定义父类 */
    open class BaseTest<T>( open val t: T) {
        open fun test() {
            println("${t} BaseTest父类 ")
        }
       fun closeTest(){
            println("父类中不能被子类重新复写的方法")
       }
    }
    
    /** * 自定义一个接口 */
    interface  TestInterface{
        //接口的成员变量默认是 open 的
        fun  test(){  println("输出自定义的接口方法 ") }
    }

输出结果：

本类是 Test子类 
    输出自定义的接口方法 
    本类是 BaseTest父类

从以上代码可知：

*  实现接口，在类头后面添加`:接口名`，而继承父类是`:父类名()`
 *  接口的方法的默认open修饰的
 *  当父类和接口或者多个接口中中有同名方法时候，调用应该使用`super<类名>.同名方法`的形式调用。
    
        //调用接口的test()
        super<TestInterface>.test()
        //调用父类的test()
        super<BaseTest>.test()

[Kotlin_Intellij IED_.kt]: http://blog.csdn.net/hexingen/article/details/72820445
[Kotlin]: http://blog.csdn.net/hexingen/article/details/72820822
[Kotlin 1]: http://blog.csdn.net/hexingen/article/details/72820984
[Kotlin 2]: http://blog.csdn.net/hexingen/article/details/72821113
[Kotlin 3]: http://blog.csdn.net/hexingen/article/details/72822247