human
Quelle est la différence entre un objet et un objet compagnon dans une classe en Kotlin ?
Exemple:
```class MaClasse {
    object Holder {
        //quelque chose
    }
    companion object {
        //quelque chose
    }
}
```
J'ai déjà lu que l'objet compagnon devrait être utilisé si les paramètres/méthodes contenus sont étroitement liés à sa classe.
Mais pourquoi y a-t-il aussi la possibilité de déclarer un objet normal dans la classe ? Parce qu'il se comporte exactement comme le compagnon, mais il doit avoir un nom.
Y a-t-il peut-être une différence dans son cycle de vie "statique" (je viens du côté Java)
gpt
Il existe deux types différents d'utilisations de ```object```, l'expression et la déclaration.
Expression d'objet
Une expression d'objet peut être utilisée lorsque qu'une classe a besoin d'une légère modification, mais il n'est pas nécessaire de créer une toute nouvelle sous-classe pour cela. Les classes internes anonymes en sont un bon exemple.
```button.setOnClickListener(object: View.OnClickListener() {
    override fun onClick(view: View) {
        // événement de clic
    }
})
```
Une chose à surveiller est que les classes internes anonymes peuvent accéder aux variables de la portée englobante, et ces variables n'ont pas besoin d'être ```final```. Cela signifie qu'une variable utilisée à l'intérieur d'une classe interne anonyme qui n'est pas considérée comme ```final``` peut changer de valeur de manière inattendue avant d'être utilisée.
Déclaration d'objet
Une déclaration d'objet est similaire à une déclaration de variable et ne peut donc pas être utilisée du côté droit d'une instruction d'affectation. Les déclarations d'objet sont très utiles pour implémenter le modèle Singleton.
```object MonObjetSingleton {
    fun getInstance(): MonObjetSingleton {
        // retourne une seule instance de l'objet
    }
}
```
Et la méthode ```getInstance``` peut ensuite être invoquée de cette manière.
```MonObjetSingleton.getInstance()
```
Objet Compagnon
Un objet compagnon est un type spécifique de déclaration d'objet qui permet à un objet d'agir de manière similaire aux objets statiques dans d'autres langages (comme Java). Ajouter ```companion``` à la déclaration de l'objet permet d'ajouter la fonctionnalité "statique" à un objet, même si le concept réel de statique n'existe pas en Kotlin. Voici un exemple d'une classe avec des méthodes d'instance et des méthodes compagnon.
```class MaClasse {
  companion object MonObjetCompagnon {
    fun agitCommeStatique() {
      // faire quelque chose
    }
  }
  fun methodeInstance() {
    // faire quelque chose
  }
}
```
L'invocation de la méthode d'instance ressemblerait à ceci.
```var maClasse = MaClasse()
maClasse.methodeInstance()
```
L'invocation de la méthode de l'objet compagnon ressemblerait à ceci.
```MaClasse.agitCommeStatique()
```
Consultez la documentation Kotlin pour plus d'informations.