Kotlin学习笔记（五）接口，可见性修饰符

提示：本文为作者阅读Kotlin中文站学习笔记，建议读者移步Kotlin中文站完整学习。

接口

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.f()//调用E中的f方法
        super.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 任务执行所编译的一套文件。