Kotlin学习之 9接口

傷城~ 2022-05-26 02:45 232阅读 0赞

# Kotlin 接口 #

Kotlin 接口与 Java 8 类似，使用 interface 关键字定义接口，允许方法有默认实现

interface MyInterface {
        fun bar()    // 未实现
        fun foo() {  //已实现
          // 可选的方法体
          println("foo")
        }
    }

java8中接口的方法也可以有默认方法，这个还真没测试过！

## 一.实现接口 ##

### 1.一个类或者对象可以实现一个或多个接口。 ###

class Child : MyInterface {
        override fun bar() {
            // 方法体
        }
    }

## 2.实例 ##

package hello                    
    interface MyInterface {
        fun bar()
        fun foo() {
            // 可选的方法体
            println("foo")
        }
    }
    class Child : MyInterface {
        override fun bar() {
            // 方法体
            println("bar")
        }
    
        //可以重写，也可以不重写
        override fun foo(){
            println("foo2")
        }
    }
    fun main(args: Array<String>) {
        val c =  Child()
        c.foo(); //如果没有重写方法，打印的是：foo
        c.bar();
    
    }

### 运行结果： ###

foo2
    bar

这里有一点比较特别注意的是Kotlin接口中，  
如果接口定义的方法有方法体，那么子类可以重写这个方法，也可以不重写这个方法，重写这个方法就会覆盖父类中的方法代码  
但是如果接口中定义的方法没有方法体，那么子类是必须要实现这个方法的。

## 二.接口中的属性 ##

接口中的属性只能是抽象的，不允许初始化值，接口不会保存属性值，实现接口时，必须重写属性：

interface MyInterface{
        
        var name:String //name 属性, 抽象的
    }
    
    class MyImpl:MyInterface{
        
        override var name: String = "runoob" //重写属性
    }

这个和java不一样，java中接口是可以定义属性值的，并且子类不用重写它属性，也不能重写它的属性。

### 实例 ###

interface MyInterface {
        var name:String //name 属性, 抽象的
        fun bar()
        fun foo() {
            // 可选的方法体
            println("foo")
        }
    }
    class Child : MyInterface {
        override var name: String = "runoob" //重写属性
        override fun bar() {
            // 方法体
            println("bar")
        }
    }
    fun main(args: Array<String>) {
        val c =  Child()
        c.foo();
        c.bar();
        println(c.name)
    
    }

#### 输出结果为： ####

foo
    bar
    runoob

## 三.方法重写 ##

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

### 1.实例 ###

package hello                    
    //接口A
    interface A {
        fun foo() { println("A") }   // 已实现
        fun bar()                  // 未实现，没有方法体，是抽象的
    }
    
    //接口B 
    interface B {
        fun foo() { println("B") }   // 已实现
        fun bar() { println("B bar") } // 已实现
    }
    
    //类只继承一个接口的情况 
    class C : A {
        override fun bar() { println("C bar") }    // 没有方法体的方法必须要被重写
        //另外一个方法，可以重写，也可以不重写
    }
    
    //类继承两个接口的情况 
    class D : A, B {
        //双继承的情况，foo方法和bar方法都是必须重写的，不管父类有没有方法体！
        //这个和C类不一样，C类是单继承（实现）
    
        override fun foo() {
            //这里可以使用泛型来确定调用哪一个父类，可以调用其中一个，可以调用两个，也可以一个都不调用
         super<A>.foo()
         super<B>.foo()
      }
    
        override fun bar() {
            //这里不能调用类A的bar()方法,因为没有方法体
            //这里只能调用有方法体的方法
            super<B>.bar()
        }
    }
    
    fun main(args: Array<String>) {
        val d =  D()
        d.foo()
        d.bar()
    
        val c=C()
        c.foo()
        c.bar()
    }

### 2.输出结果为： ###

A
    B
    B bar
    A
    C bar

实例中接口 A 和 B 都定义了方法 foo() 和 bar()， 两者都实现了 foo(), B 实现了 bar()。  
因为 C 是一个实现了 A 的具体类，所以必须要重写 bar() 并实现这个抽象方法。

然而，如果我们从 A 和 B 派生 D，我们需要实现多个接口继承的所有方法，并指明 D 应该如何实现它们。  
这一规则 既适用于继承单个实现（bar()）的方法也适用于继承多个实现（foo()）的方法。  
在子类D中是设计到两个概念的，重写和调用，这两个关系是分开的，重写和不重写，有时候是强制的，但是调不调用父类是一定不强制的。

Kotlin接口相关知识就介绍到这里。  
大家可以测试一下：[https://blog.csdn.net/wenzhi20102321/article/details/79859347][https_blog.csdn.net_wenzhi20102321_article_details_79859347]

# 共勉：没有伞的孩子务必发奋奔跑! #

[https_blog.csdn.net_wenzhi20102321_article_details_79859347]: https://blog.csdn.net/wenzhi20102321/article/details/79859347