Kotlin 简明教程

Kotlin - Visibility Control (Modifiers)

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

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

  1. public

  2. private

  3. protected

  4. internal

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

Public Modifier

Public 修饰符可以在项目工作空间的任何位置访问。如果未指定访问修饰符，则默认情况下它将在公共范围内。在我们之前的所有示例中，我们没有提到任何修饰符，因此，它们都在公共范围内。以下是一个示例，以进一步了解如何声明公共变量或方法。

class publicExample {
   val i = 1

   fun doSomething() {
   }
}

在上面的示例中，我们没有提到任何修饰符，因此此处定义的方法和变量默认为公共的。虽然上面的示例可以通过 public 修饰符明确地写入如下：

public class publicExample {
   public val i = 1

   public fun doSomething() {
   }
}

Private Modifier

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

private class privateExample {
   private val i = 1

   private val doSomething() {
   }
}

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

Example

我们来看一个简单的示例，说明如何使用私有成员：

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 ，因为它已被定义为私有的，这意味着它可以在类本身内部访问，而不能在其他地方访问。

Protected Modifier

Protected 是 Kotlin 的另一个访问修饰符，它目前不可用于像任何包一样不能被保护的顶级声明。受保护的类或接口或属性或函数对类本身及其子类可见。

package one;

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

在上面的示例中，变量 i 被声明为受保护的，因此它只能对类本身及其子类可见。

Example

我们来看一个简单的示例，说明如何使用受保护成员：

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() ，因为它已被定义为受保护的，这意味着它只能在类本身或其子类中访问。

Internal Modifier

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

package one

internal class InternalExample {
}

class publicExample{
    internal val i = 1

    internal fun doSomething() {
    }
}

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

Example

我们来看一个简单的示例，说明如何使用内部成员：

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