Quelle est la différence entre un objet à l'intérieur d'une classe et un compagnon d'objet en Kotlin?

Un objet interne (inner object) à l'intérieur d'une classe est lié à une instance de la classe externe et n'existe que dans son cycle de vie. L'objet compagnon (companion object) existe en tant que singleton, non lié à une instance de la classe, et peut être accessible directement via le nom de la classe.

Principales différences :

• Liaison à l'instance : inner object est lié à une instance de la classe externe, companion object ne l'est pas.
• Accès : on peut accéder à inner object uniquement via une instance de la classe externe, à companion object directement via le nom de la classe.
• État : inner object peut avoir un état spécifique à l'instance, companion object est commun à toute la classe.
• Utilisation : inner object est souvent utilisé pour implémenter le pattern State ou pour grouper des objets liés à l'intérieur d'une instance. companion object est utilisé pour des méthodes de fabrique, des constantes ou des membres statiques de la classe.

Exemple :

class Outer {
    private var outerValue: Int = 0

    inner object InnerObject {
        fun accessOuterValue(): Int {
            return outerValue // inner object a accès aux membres de la classe externe
        }
    }

    companion object CompanionObject {
        const val CONSTANT = "Some constant"

        fun createOuter(): Outer {
            return Outer() // méthode de fabrique
        }
    }
}

fun main() {
    val outer = Outer.CompanionObject.createOuter() // accès au companion object
    // val inner = Outer.InnerObject // Erreur : impossible d'accéder à InnerObject sans une instance de Outer
    val inner = outer.InnerObject // accès à l'objet interne via l'instance

    println(inner.accessOuterValue())
    println(Outer.CompanionObject.CONSTANT)
    println(Outer.CONSTANT) // sucre syntaxique pour accéder aux membres de CompanionObject
}