可见性修饰符

Kotlin有​​private​​​,​​protected​​​,​​internal​​​,​​public​​​四个修饰符。Kotlin的类、对象、接口、构造函数、函数、属性和它的​​getters​​​和​​setters​​​都可以用这些修饰符修饰。如果没有明确指定修饰符，那么它默认就是​​public​​。

包

函数、属性、类、对象、接口都可以定义在顶层，即直接定义在包里。

// file name :demo.kt
fun baz() { ... } // 顶层函数
class Bar { ... } // 顶层类
  • 如果你没有指定任何可见性修饰，默认使用​​public​​，意味着你的定义将会在到处可见。即在任何地方都可以调用到。
  • 如果你用​​private​​标记了一个声明，那么它将只能在包含声明的文件中可见。
  • 如果你标记它为​​internal​​ ，它在同一个模块中是可见的。
  • ​​protected​​对于顶层声明是不可用的。
// file name: example.kt
package foo
private fun foo() { ... } // 在example.kt文件中可见
public var bar: Int = 5 // 在任何地方，属性bar都是可见的
private set // setter只能在example.kt文件中可见

internal val baz = 6 // 在同一模块中可见
// file name: example.kt
package com.example.demo

// 顶层函数
// public是默认的，可以不写，在任何地方都可见
public fun a(){}
internal fun b(){}// 只在模块中可见
private fun c(){} // 只能在文件example.kt中可见。
protected fun d(){}// 错误！错误！错误！在顶层中protected关键字不可用

// 接口
public interface A{}// 默认的，到处可见
private interface B{} // 在当前文件可见
internal interface C{} // 在模块中可见
protected interface D{}// 错误！错误！错误！在顶层关键字interface                                                                                       
class E {
    
}

 // 类
class A public constructor(){}// 默认的，到处可见
class B private constructor(){}// 在当前文件可见
class C internal constructor(){} // 在模块中可见
class D protected constructor(){

}

顶层属性

public var num: Int = 1  // 默认的，到处可见
private var num2: Int = 2 // 在当前文件可见
internal var num3: Int = 3 // 在模块中可见
protected var num4: Int 4 // 错误！错误！错误！

类和接口

对于在一个类中定义的成员：

  • ​​private​​意味着只在这个类可见（包括所有它的成员）
  • ​​protected​​成员在子类中可见
  • ​​interal​​此模块中任何看到声明类的客户端都会看到其内部成员
  • ​​public​​​ 任何看到声明类的客户机都会看到它的公共成员
    注意在Kotlin中，外部类不能看见它的内部类的​​​private​​​成员。如果你重写了一个​​protected​​​成员，并且不显式指定可见性，那么该成员的可见性仍是​​protected​​
open class Outer {
  private val a = 1
  protected open val b = 2
  internal val c = 3
  val d = 4 // 默认public
  
  protected class Nested {
    public val e: Int = 5
  }
}

class Subclass : Outer() {
  // a 是不可见的
  // b, c, d 是可见的
  // Nested 和 e 是可见的
  override val b = 5 // 没有重新指定修饰符，所以仍然是protected
}
class Unrelated(o: Outer) {
  // o.a, o.b 不可见
  // o.c， o.d  是可见的 are visible (same module)
  // Outer.Nested是不可见的，Nested::e也是不可见的
}

构造函数

用如下语法，指定一个类的主构造函数的可见性（此时constructor关键字不可省略）：

class C private constructor(a: Int) { ... }

这里构造函数是​​private​​​。默认，所有构造函数是​​public​​​。一个​​internal​​​类的构造函数只能在同一个模块中可见。
这里的模块（Modules）可见性修饰符意味着成员在同一个模块中可见。更具体些说，一个模块就是编译在一起的Kotlin文件集合：

  • 一个Intellij IDEA Module
  • 一个Maven项目
  • 一个Gradle source set

局部变量、局部函数、局部类不能有可见性修饰符。如定义在函数体内部的变量、函数、类变量等，都不能用可见性修饰符修饰。