介面

Kotlin中，使用關鍵字interface定義一個介面。與Java8類似，介面中即可以包含抽象方法的宣告，也可以包含實現。與抽象類不同的時，介面不儲存屬性的狀態，屬性要麼宣告為抽象，要麼提供訪問器實現。並且在介面中宣告的屬性沒有幕後欄位，所以在訪問器中不能引用field欄位。

interface Base {
    var arg1: String//抽象屬性
    var arg2: String//在介面中宣告的屬性不能有幕後欄位（backing field），因此介面中宣告的訪問器不能引用它們。
        get() = "arg2"
        set(value) {
            arg2 = value
        }

    fun fun1(): Unit//抽象方法
 


    fun fun2(): Unit {//方法實現
        print("fun2 in Base")
    }
}

//I實現Base介面
class I : Base {

    //實現Base中的arg1屬性
    override var arg1: String
        get() = TODO("not implemented")
        set(value) {}

    //覆蓋Base中arg2屬性
    override var arg2: String
        get() = super.arg2
        set(value) {}

    //實現Base中的fun1方法
 

    override fun fun1() {
        fun2()//呼叫Base中的fun2方法
        print(arg2)//列印Base中的arg2屬性
    }

    //覆蓋Base中的fun2方法實現
    override fun fun2() {
        super.fun2()
    }

}

一個類 可以實現多個介面。當一個類有多個超類時，可能會出現類中的一個成員，有超類的多個實現，此時，如果我們要呼叫超類中的實現，可以使用尖括號中超類名的方式來訪問。

interface E{
    fun f():Unit{
        print("f in E"
 
)
    }
}

interface F{
    fun f():Unit{
        print("f in F")
    }
}

class D:E,F{

    override fun f() {
        super<E>.f()//呼叫E中的f方法
        super<F>.f()//呼叫F中的f方法
    }

}

可見性修飾符

Kotlin中，提供了四種可見性修飾符：public，internal，protected，private。

類，介面，物件，方法，屬性，屬性的setter方法（屬性的getter方法總是與屬性可見性相同）都可以使用可見性修飾符修飾。如果沒有顯式指定可見性修飾符，預設是public。

在一個Kotlin檔案內，類，介面，物件，屬性，方法都可以在頂層宣告。除了protected修飾符不適用於頂層宣告元素外，其它可見性修飾符都可以用來修飾頂層宣告元素，此時：

• public 宣告隨處可見
• internal 宣告在相同模組內可見
• private 宣告在本檔案內可見

//檔名File4.kt
package com.gyg.kolin

//沒有顯式指定可見性修飾符的情況下，可見性預設是public，即K類隨處可見
class K{
}

//internal修飾符表示property屬性，只在本模組(即頭部宣告的com.gyg.kolin包)內可見
internal var proterty:String=""

//private 修飾符表示_fun()方法只在本檔案（File4.kt）內可見，其它地方都訪問不到
private fun _fun():Unit{
}

對於類或者介面內宣告的成員：

• public 能見到類宣告的任何客戶端都可以見到其public成員
• internal 能見到類宣告的本模組內的任何客戶端都可以見到其public成員
• protected 只在本類內部+子類中可見
• private 本類內部（包含其所有成員）都可見

open class K{
    public var property:String="property"//類可見的任何客戶端都可見
    internal var property2:String="property2"//類可見的本模組內可見
    protected var property3:String="property3"//本類及子類可見
    private var property4:String="property4"//只在本類可見

    private fun _fun(){
        print(innerK().innerProperty)//protected innerK可見,public innerProperty可見
        print(innerK().innerProperty2)//protected innerK可見,internal innerProperty2可見
        //print(innerK().innerProperty3)// protected innerK可見,private innerProperty不可見
    }

    protected class innerK{
        public var innerProperty:String="innerProperty"
        internal var innerProperty2:String="innerProperty2"
        private var innerProperty3:String="innerProperty3"
    }

    private class innerK2{
        public var innerProperty:String="innerProperty"
        internal var innerProperty2:String="innerProperty2"
        private var innerProperty3:String="innerProperty3"
    }
}

class K2: K() {

    public fun _fun(){
        print(property)//public property可見
        print(property2)//internal property2可見
        print(property3)//protected property3可見
        print(innerK().innerProperty)//protected innerK可見,public innerProperty可見
        print(innerK().innerProperty2)//protected innerK可見,internal innerProperty2可見
        //protected innerK 可見.但private innerProperty3不可見
       //private innerK2不可見，它裡面的所有成員都不可見
    }
}

class K3{

    fun _fun(){
        print(K().property)//public K可見，public property可見
        print(K().property2)//public K可見,internal property2可見
        //K().property3 //public K可見，但protecte property3不可見
        //protected innerK 不可見，它裡面的所有成員都不可見
        //private innerK2 不可見，它裡面的所有成員都不可見
    }
}

可以通過以下方式指定一個類的主建構函式的可見性：

class A private constructor(arg1:String){
}

以上主建構函式私有，只能在本類內例項化。預設，主建構函式可見性public，即類可見的地方都可以例項化。

區域性變數，函式和類不能有可見性修飾符。

可見性修飾符 internal 意味著該成員只在相同模組內可見。更具體地說， 一個模組是編譯在一起的一套 Kotlin 檔案：

• 一個 IntelliJ IDEA 模組；
• 一個 Maven 或者 Gradle 專案；
• 一次 ＜kotlinc＞ Ant 任務執行所編譯的一套檔案。