Cosa sono i modificatori di visibilità e come usarli in Kotlin?

I modificatori di visibilità in Kotlin determinano l'accessibilità delle dichiarazioni (classi, interfacce, funzioni, proprietà) alle altre parti del programma.

I principali modificatori di visibilità:

• public: Visibile ovunque. È il modificatore di default.
• internal: Visibile solo all'interno di un modulo. Un modulo è considerato un insieme di file Kotlin compilati insieme.
• protected: Visibile all'interno della classe e delle sue sottoclassi (inclusi i membri definiti nelle classi derivate). Non visibile al di fuori del package.
• private: Visibile solo all'interno del file in cui è dichiarato. Per i membri di classe, solo all'interno di quella classe (e del suo oggetto companion, classi annidate e interne).

Applicazione dei modificatori:

• A classi, interfacce, oggetti e loro costruttori.
• A funzioni, proprietà e loro getter/setter a livello superiore (fuori dalle classi).
• A membri di classe (classi annidate, interne, funzioni, proprietà).

Esempio:

// File: example.kt

private const val PRIVATE_CONSTANT = 1 // Visibile solo in questo file

internal fun internalFunction() { // Visibile solo all'interno del modulo
    println("Funzione interna chiamata")
}

open class BaseClass {
    protected val protectedProperty = "Protetto" // Visibile in questa classe e nelle sue sottoclassi

    fun publicMethod() { // Visibile ovunque (public di default)
        println("Metodo pubblico chiamato")
    }

    private fun privateMethod() { // Visibile solo all'interno di BaseClass
        println("Metodo privato chiamato")
    }
}

class DerivedClass : BaseClass() {
    fun accessProtected() {
        println("Accesso alla proprietà protetta: $protectedProperty") // Accesso a protected
        // privateMethod() // Errore: private non visibile nella sottoclasse
    }
}

fun main() {
    val base = BaseClass()
    base.publicMethod()
    // base.protectedProperty // Errore: protected non visibile fuori dalla classe e dalle sue sottoclassi

    val derived = DerivedClass()
    derived.accessProtected()

    internalFunction()
    // PRIVATE_CONSTANT // Errore: private a livello superiore visibile solo nel file di dichiarazione
}

Modificatore	Accessibilità	Dove usare
public	Ovunque	Per default, quando non viene specificato un altro modificatore
internal	All'interno del modulo	Per API all'interno di una libreria o di un modulo
protected	All'interno della classe e delle sue sottoclassi (per i membri)	Per creare gerarchie di classi con ereditarietà
private	All'interno del file (a livello superiore); all'interno della classe (per i membri)	Per nascondere dettagli di implementazione all'interno del file o della classe