Kotlin - 可见性控制（修饰符）

---

---

Kotlin 的可见性修饰符是用于设置类、对象、接口、构造函数、函数以及属性及其设置器可见性的关键字。尽管 getter 始终与其属性具有相同的可见性，因此我们无法设置其可见性。

Setter 是用于设置属性值的函数，而 getter 是用于获取这些属性值的函数。

Kotlin 中有四个可见性修饰符

• public

• private

• protected

• internal

默认可见性为 public。这些修饰符可以在多个位置使用，例如类头或方法体。让我们详细了解这些修饰符。

Public 修饰符

Public 修饰符可在项目工作区的任何位置访问。如果未指定访问修饰符，则默认情况下它将处于 public 范围。在我们之前的所有示例中，我们都没有提及任何修饰符，因此，它们都处于 public 范围。以下是一个示例，用于更深入地了解如何声明 public 变量或方法。

class publicExample {
   val i = 1
   
   fun doSomething() {
   }
}

在上面的示例中，我们没有提及任何修饰符，因此此处定义的方法和变量默认情况下为 public。虽然上面的示例可以使用 **public** 修饰符显式地编写如下

public class publicExample {
   public val i = 1
   
   public fun doSomething() {
   }
}

Private 修饰符

类、方法、包和其他属性可以使用 **private** 修饰符声明。此修饰符与 public 的含义几乎完全相反，这意味着私有成员无法在其范围之外访问。一旦任何内容被声明为 private，则只能在其直接范围内访问。例如，私有包可以在该特定文件中访问。私有类或接口只能由其数据成员访问，等等。

private class privateExample {
   private val i = 1
   
   private val doSomething() {
   }
}

在上面的示例中，类 **privateExample** 只能从同一个源文件中访问，变量 **i** 和方法 **doSomething** 只能从 privateExample 类内部访问。

示例

让我们检查一个简单的示例，展示私有成员的使用。

open class A() {
   private val i = 1
   
   fun doSomething(){
      println("Inside doSomething" )
      println("Value of i is $i" )
   }
}
class B : A() {
   fun printValue(){
       doSomething()
       // println("Value of i is $i" )
   }
}

fun main(args: Array<String>) {  
   val a = A()
   val b = B()
   
   b.printValue()
}  

运行上面的 Kotlin 程序时，将生成以下输出

Inside doSomething
Value of i is 1

在这里，我们无法访问类 B 内部的变量 **i**，因为它已定义为 private，这意味着它只能在类本身内部访问，其他地方无法访问。

Protected 修饰符

Protected 是 Kotlin 的另一个访问修饰符，目前不适用于顶级声明，例如任何包都不能是 protected。受保护的类或接口或属性或函数仅对其自身及其子类可见。

package one;

class A() {
   protected val i = 1
}
class B : A() {
   fun getValue() : Int {
      return i
   }
}

在上面的示例中，变量 **i** 声明为 protected，因此，它仅对类本身及其子类可见。

示例

让我们检查一个简单的示例，展示受保护成员的使用。

open class A() {
   protected val i = 1
   
   protected fun doSomething(){
      println("Inside doSomething" )
      println("Value of i is $i" )
   }
}
class B : A() {
   fun printValue(){
       doSomething()
       println("Value of i is $i" )
   }
}

fun main(args: Array<String>) {  
   val a = A()
   val b = B()
   
   //a.doSomething()
   
   b.printValue()
}  

运行上面的 Kotlin 程序时，将生成以下输出

Inside doSomething
Value of i is 1
Value of i is 1

在这里，我们甚至无法使用 A 类的对象调用 **doSomething()**，因为它已定义为 protected，这意味着它只能在类本身或其子类中访问。

Internal 修饰符

Internal 是 Kotlin 中新添加的修饰符。如果任何内容被标记为 internal，则该特定字段将被标记为 internal 字段。Internal 包仅在其实现的模块内可见。Internal 类接口仅由同一包或模块内的其他类可见。在下面的示例中，我们将看到如何实现 internal 方法。

package one

internal class InternalExample {
}

class publicExample{
    internal val i = 1

    internal fun doSomething() {
    }
}

在上面的示例中，类 **InternalExample** 只能从同一个模块内部访问，类似地，变量 **i** 和函数 **doSomething()** 也只能从同一个模块内部访问，即使类 **publicExample** 可以从任何地方访问，因为此类默认具有 **public** 可见性。

示例

让我们检查一个简单的示例，展示 internal 成员的使用。

package com.tutorialspoint.modifiers

open class A() {
   internal val i = 1
   
   internal fun doSomething(){
      println("Inside doSomething" )
      println("Value of i is $i" )
   }
}
class B : A() {
   fun printValue(){
       doSomething()
       println("Value of i is $i" )
   }
}

fun main(args: Array<String>) {  
   val a = A()
   val b = B()
   
   a.doSomething()
   
   b.printValue()
}  

运行上面的 Kotlin 程序时，将生成以下输出

Inside doSomething
Value of i is 1
Inside doSomething
Value of i is 1
Value of i is 1