Explique ce qu'est un 'companion object' dans le…

companion object — c'est un objet spécial associé à une classe, mais qui n'est pas une instance de celle-ci. Il agit comme des membres statiques en Java.

Points clés:

Déclaré à l'intérieur de la classe avec le mot-clé companion object.
A accès aux membres privés de la classe.
Peut avoir un nom, mais est généralement omis (le nom Companion est utilisé).
Les membres du companion object peuvent être accédés directement via le nom de la classe, sans créer d'instance.

Exemples d'utilisation:

Méthodes de fabrique: Pour créer des instances de la classe avec une logique d'initialisation plus complexe que les constructeurs classiques.

class MyClass private constructor(val value: String) { // Constructeur privé

    companion object {
        fun create(input: String): MyClass { // Méthode de fabrique
            // Logique de traitement de l'input
            return MyClass("Processed: $input")
        }
    }
}

fun main() {
    val instance = MyClass.create("some data") // Utilisation de la méthode de fabrique
    println(instance.value)
}

Constantes au niveau de la classe: Pour définir des valeurs accessibles sans créer d'instance.

class Constants {
    companion object {
        const val DEFAULT_VALUE = "default" // Constante
    }
}

fun main() {
    println(Constants.DEFAULT_VALUE) // Accès à la constante
}

Implémentation d'interfaces: Le companion object peut implémenter des interfaces, ce qui est utile pour simuler des fabriques statiques avec une fonctionnalité commune.

interface Factory<T> {
    fun create(): T
}

class MyData(val id: Int) {
    companion object : Factory<MyData> {
        private var nextId = 0
        override fun create(): MyData {
            return MyData(nextId++)
        }
    }
}

fun main() {
    val data1 = MyData.create()
    val data2 = MyData.create()
    println(data1.id)
    println(data2.id)
}

Extensions: Le companion object peut être étendu, permettant d'ajouter des méthodes "statiques" à la classe depuis l'extérieur.

class MyUtil {
    companion object {
        // Objet compagnon vide
    }
}

fun MyUtil.Companion.helperMethod() { // Extension de l'objet compagnon
    println("Called helper method")
}

fun main() {
    MyUtil.helperMethod()
}

En général, il faut utiliser companion object lorsque vous avez besoin d'une fonctionnalité liée à la classe, mais qui ne nécessite pas une instance de celle-ci. C'est une façon plus idiomatique en Kotlin d'atteindre ce que Java réalise avec des membres statiques, tout en offrant une plus grande flexibilité (par exemple, dans la mise en œuvre d'interfaces et d'extensions). Il ne faut pas en abuser pour stocker un état qui doit être unique pour chaque instance.

Explique ce qu'est un 'companion object' dans le langage Kotlin et dans quels cas il doit être utilisé.