Модификаторы (контроль видимости)

Модификаторы видимости Kotlin — это ключевые слова, которые устанавливают видимость классов, объектов, интерфейса, конструкторов, функций, а также свойств и их сеттеров. Поскольку геттеры всегда имеют ту же видимость, что и их свойства, мы не можем установить их видимость. Сеттеры — это функции, которые используются для установки значений свойств, а геттеры — это функции, которые используются для получения значений этих свойств.

В Kotlin есть четыре модификатора видимости:

• public
• private
• protected
• internal

Видимость по умолчанию public. Эти модификаторы можно использовать в нескольких местах, таких как заголовок класса или тело метода. Давайте рассмотрим детали этих модификаторов:

Модификатор Public (публичный)

Public (публичный) модификатор доступен из любой точки рабочей области проекта. Если модификатор доступа не указан, то по умолчанию он public. Во всех наших предыдущих примерах мы не упомянули ни одного модификатора, следовательно, все они находятся в общедоступной области. Ниже приведен пример, чтобы лучше понять, как объявить общедоступную переменную или метод.

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

В приведенном выше примере мы не упомянули ни одного модификатора, поэтому определенные здесь метод и переменная по умолчанию общедоступны. Хотя приведенный выше пример может быть явно написан с модификатором public следующим образом:

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

Модификатор Private (частный)

Классы, методы, пакеты и другие свойства могут быть объявлены с модификатором private. Этот модификатор имеет почти прямо противоположное значение public, что означает, что члены класса private не могут быть доступны за пределами области private класса. Как только что-нибудь объявлено как 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("Внутри что-то есть" )
      println("Значение i равно $i" )
   }
}
class B : A() {
   fun printValue(){
       doSomething()
       // println("Значение i равно $i" )
// Если вывести то будет ошибка
   }
}

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

Здесь мы не можем получить доступ к переменной i внутри класса B, потому что она была определена как частная, что означает, что к ней можно получить доступ изнутри самого класса и нигде больше.

Модификатор Protected (защищенный)

Protected — это еще один модификатор доступа для Kotlin, который в настоящее время недоступен для объявления верхнего уровня, поскольку ни один пакет не может быть защищен. Защищенный класс, интерфейс, свойства или функция видны самому классу и только его подклассам.

package one;

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

В приведенном выше примере переменная i объявлена ​​как защищенная, следовательно, она видна только самому классу и его подклассам.

Давайте проверим простой пример, показывающий использование защищенных членов:

open class A() {
   protected val i = 1
   
   protected fun doSomething(){
      println("Внутри что-то есть" )
      println("Значение i равно $i" )
   }
}
class B : A() {
   fun printValue(){
       doSomething()
       println("Значение i равно $i" )
   }
}

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

Здесь мы не можем вызвать doSomething(), используя объект класса A, потому что он был определен как защищенный, что означает, что к нему можно получить доступ внутри самого класса или только в его подклассах.

Модификатор Internal (внутренний)

Internal — это недавно добавленный модификатор в Kotlin. Если что-либо помечено как внутреннее, то конкретное поле будет помечено как внутреннее поле. Внутренний пакет виден только внутри модуля, в котором он реализован. Интерфейс внутреннего класса виден только другому классу, присутствующему внутри того же пакета или модуля. В следующем примере мы увидим, как реализовать внутренний метод.

package one

internal class InternalExample {
}

class publicExample{
    internal val i = 1

    internal fun doSomething() {
    }
}

В приведенном выше примере класс InternalExample доступен только внутри того же модуля, аналогичным образом переменная i и функция doSomething() также доступны только внутри того же модуля, хотя к классу publicExample можно получить доступ из любого места, поскольку этот класс public по умолчанию.

Давайте проверим простой пример:

package ru.jandroid.modifiers

open class A() {
   internal val i = 1
   
   internal fun doSomething(){
      println("Внутри что-то есть" )
      println("Значение переменной i равно $i" )
   }
}
class B : A() {
   fun printValue(){
       doSomething()
       println("Значение переменной i равно $i" )
   }
}

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