Modificatori di Visibilità Kotlin – pubblico, protetto, interno, privato

In questo tutorial, discuteremo i vari modificatori di visibilità disponibili nella programmazione Kotlin.

Modificatori di Visibilità Kotlin

I modificatori di visibilità sono modificatori che, quando aggiunti a una classe/interfaccia/proprietà/funzione in Kotlin, definiscono dove è visibile e da dove può essere accessibile. I setter delle proprietà in Kotlin possono avere un modificatore separato rispetto alla proprietà. I getter non possono avere un modificatore di visibilità definito. Utilizzano lo stesso modificatore della proprietà. Di seguito sono riportati i modificatori di visibilità:

• pubblico
• protetto
• interno
• privato

Modificatore Pubblico

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

Tutte le dichiarazioni sopra sono nel livello superiore del file. TUTTE sono pubbliche. Se non menzioniamo la dichiarazione dei membri della classe, sono pubblici (a meno che non siano sovrascritti).

Modificatore Protetto

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
    }
}

Le classi che non sono sottoclassi di Pr non possono accedere alle dichiarazioni di i che sono protette, quando sovrascritte avrebbero lo stesso modificatore protetto nella sottoclasse a meno che tu non le cambi esplicitamente.

open class Pr{
    open protected val i = 0
}

class Another : Pr(){

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

Il concetto di modificatori protetti in Kotlin che è stato definito sopra differisce da quello in Java.

Modificatore Interno

Interno è un nuovo modificatore disponibile in Kotlin che non esiste in Java. Impostare una dichiarazione come interna significa che sarà disponibile solo nello stesso modulo. Per modulo in Kotlin intendiamo un gruppo di file compilati insieme.

internal class A {
}

internal val x = 0

Queste non saranno visibili al di fuori del modulo corrente. I modificatori interni sono utili quando è necessario nascondere implementazioni specifiche della libreria agli utenti. Questo non era possibile utilizzando la visibilità package-private in Java.

Modificatori Privati

I modificatori privati non consentono alle dichiarazioni di essere visibili al di fuori dell’ambito corrente.

var setterVisibility: String = "abc"
private set

open class Pr{
    open protected val i = 0

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

Dato che Kotlin consente definizioni multiple al livello superiore, il codice sopra funziona. Il seguente no.

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) {
 ... 
}

Per impostazione predefinita, le classi hanno costruttori pubblici. Ovunque vada la classe, segue il costruttore. È necessario impostare il modificatore di visibilità sul costruttore nella stessa definizione. Pertanto, Kotlin utilizza i modificatori protetto e interno in modo diverso rispetto a Java. Inoltre, il modificatore predefinito di Java è “package-private”, che non esiste ancora in Kotlin. Questo conclude questo breve tutorial sui modificatori di visibilità in Kotlin.