Kotlin Zichtbaarheidsmodificatoren – public, protected, internal, private

In deze tutorial zullen we de verschillende Zichtbaarheidsmodificatoren bespreken die beschikbaar zijn in Kotlin-programmering.

Kotlin Zichtbaarheidsmodificatoren

Zichtbaarheidsmodificatoren zijn modificatoren die, wanneer toegevoegd aan een klasse/interface/eigenschap/functie in Kotlin, bepalen waar het allemaal zichtbaar is en van waaruit het allemaal toegankelijk kan zijn. De setters van eigenschappen in Kotlin kunnen een aparte modificator hebben van de eigenschap. De getters kunnen geen zichtbaarheidsmodificator hebben gedefinieerd. Ze gebruiken dezelfde modificator als die van de eigenschap. Hieronder volgen de zichtbaarheidsmodificatoren:

• public
• protected
• internal
• private

Openbare Modificator

A Public Modifier is the default modifier in Kotlin. Just like the Java public modifier, it means that the declaration is visible everywhere.

class Hello{
}

public class H{
}

fun hi()
public fun hello()

val i = 0
public val j = 5

Alle bovengenoemde declaraties zijn op het hoogste niveau van het bestand. ALLE zijn openbaar. Als we de declaratie van de leden van de klasse niet vermelden, zijn ze openbaar (tenzij ze worden overschreven).

Beschermde Modificator

A Protected Modifier in Kotlin: CANNOT be set on top-level declarations. Declarations that are protected in a class, can be accessed only in their subclasses.

open class Pr{
    protected val i = 0
}

class Another : Pr{

    fun iValue() : Int
    {
        return i
    }
}

Klassen die geen subklasse zijn van Pr kunnen geen toegang krijgen tot i Declaraties die beschermd zijn, hebben dezelfde beschermde modifier in de subklasse wanneer ze worden overschreven, tenzij u ze expliciet wijzigt.

open class Pr{
    open protected val i = 0
}

class Another : Pr(){

    fun iValue() : Int
    {
        return i
    }
    
    override val i = 5 //protected visibility
}

Het concept van beschermde modifiers in Kotlin dat hierboven is gedefinieerd, verschilt van dat in Java.

Interne modifier

Intern is een nieuwe modifier die beschikbaar is in Kotlin en die niet in Java aanwezig is. Door een declaratie als intern in te stellen, betekent dit dat het alleen beschikbaar zal zijn in dezelfde module. Met module in Kotlin bedoelen we een groep bestanden die samen worden gecompileerd.

internal class A {
}

internal val x = 0

Deze zullen buiten de huidige module niet zichtbaar zijn. Interne modifiers zijn nuttig wanneer u specifieke bibliotheekimplementaties voor gebruikers wilt verbergen. Dit was niet mogelijk met de package-private zichtbaarheid in Java.

Privé modifiers

Prive-modifiers staan niet toe dat de declaraties buiten de huidige scope zichtbaar zijn.

var setterVisibility: String = "abc"
private set

open class Pr{
    open protected val i = 0

    fun iValue() : Int
    {
        setterVisibility = 10
        return setterVisibility
    }
}

Aangezien Kotlin meerdere topniveaudefinities toestaat, werkt de bovenstaande code. De onderstaande code niet

private open class ABC{
    private val x = 6
}

private class BDE : ABC()
{
    fun getX()
    {
        return x //x cannot be accessed here.
    }
}

x is visibile only from inside its class. We can set private constructors in the following way:

class PRIV private constructor(a: String) {
 ... 
}

Standaard hebben klassen openbare constructeurs. Waar de klasse ook heengaat, de constructor volgt. We moeten de zichtbaarheidsmodifier op de constructor zelf instellen in de definitie. Daarom gebruikt Kotlin de beschermde en interne modifiers anders dan Java. Ook de standaardmodifier van Java is pakket-privé, wat nog niet bestaat in Kotlin. Dit brengt een einde aan deze snelle tutorial over Zichtbaarheidsmodificatoren in Kotlin.