Qu'est-ce que les modificateurs de visibilité et…

Les modificateurs de visibilité en Kotlin déterminent l'accessibilité des déclarations (classes, interfaces, fonctions, propriétés) pour d'autres parties du programme.

Les principaux modificateurs de visibilité:

public: Visible partout. C'est le modificateur par défaut.
internal: Visible uniquement à l'intérieur d'un module. Un module est considéré comme un ensemble de fichiers Kotlin compilés ensemble.
protected: Visible à l'intérieur de la classe et de ses sous-classes (y compris les membres définis dans des classes dérivées). Non visible en dehors du package.
private: Visible uniquement à l'intérieur du fichier où il est déclaré. Pour les membres de classe, seulement à l'intérieur de cette classe (et de son objet compagnon, classes imbriquées et internes).

Application des modificateurs:

Aux classes, interfaces, objets et leurs constructeurs.
Aux fonctions, propriétés et leurs getters/setters au niveau supérieur (en dehors des classes).
Aux membres de classe (classes imbriquées, internes, fonctions, propriétés).

Exemple:

// Fichier : example.kt

private const val PRIVATE_CONSTANT = 1 // Visible uniquement dans ce fichier

internal fun internalFunction() { // Visible uniquement à l'intérieur du module
    println("Fonction interne appelée")
}

open class BaseClass {
    protected val protectedProperty = "Protégé" // Visible dans cette classe et ses sous-classes

    fun publicMethod() { // Visible partout (public par défaut)
        println("Méthode publique appelée")
    }

    private fun privateMethod() { // Visible uniquement à l'intérieur de BaseClass
        println("Méthode privée appelée")
    }
}

class DerivedClass : BaseClass() {
    fun accessProtected() {
        println("Accès à la propriété protégée : $protectedProperty") // Accès à protected
        // privateMethod() // Erreur : private non visible dans la sous-classe
    }
}

fun main() {
    val base = BaseClass()
    base.publicMethod()
    // base.protectedProperty // Erreur : protected non visible en dehors de la classe et de ses sous-classes

    val derived = DerivedClass()
    derived.accessProtected()

    internalFunction()
    // PRIVATE_CONSTANT // Erreur : private au niveau supérieur visible uniquement dans le fichier de déclaration
}

Modificateur	Accessibilité	Où utiliser
`public`	Partout	Par défaut, lorsque aucun autre modificateur n'est spécifié
`internal`	À l'intérieur du module	Pour API à l'intérieur d'une bibliothèque ou d'un module
`protected`	À l'intérieur de la classe et de ses sous-classes (pour les membres)	Pour créer des hiérarchies de classes avec héritage
`private`	À l'intérieur du fichier (niveau supérieur); à l'intérieur de la classe (pour les membres)	Pour masquer les détails d'implémentation à l'intérieur du fichier ou de la classe

Qu'est-ce que les modificateurs de visibilité et comment les utiliser en Kotlin?