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

---

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

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

Kotlin 中有四种可见性修饰符：

• 民众

• 私人的

• 受保护的

• 内部的

默认可见性是公开的。这些修饰符可以在多个地方使用，例如类头或方法体。让我们看看这些修饰符的详细信息：

公共修改器

可以从项目工作区中的任何位置访问公共修改器。如果未指定访问修饰符，则默认情况下它将位于公共范围内。在我们之前的所有示例中，我们没有提到任何修饰符，因此，它们都在公共范围内。以下是一个示例，可帮助您了解有关如何声明公共变量或方法的更多信息。

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

在上面的例子中，我们没有提到任何修饰符，所以这里定义的方法和变量默认是public的。尽管上面的示例可以使用public修饰符显式编写，如下所示：

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

私有修改器

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

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 是 Kotlin 的另一个访问修饰符，目前不可用于顶级声明，就像任何包都无法受到保护一样。受保护的类、接口、属性或函数仅对该类本身及其子类可见。

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 是 Kotlin 中新添加的修饰符。如果任何内容被标记为内部，则特定字段将被标记为内部字段。内部包仅在其实现所在的模块内部可见。内部类接口仅对同一包或模块中存在的其他类可见。在下面的示例中，我们将看到如何实现内部方法。

package one

internal class InternalExample {
}

class publicExample{
    internal val i = 1

    internal fun doSomething() {
    }
}

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

例子

让我们看一个简单的例子，显示内部成员的用法：

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