Kotlin可见性修饰符

可见性修饰符

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

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