web-dev-qa-db-fra.com

Kotlin: Différence entre objet et objet compagnon dans une classe

Quelle est la différence entre un objet et un objet compagnon dans une classe de kotlin?

Exemple:

class MyClass {

    object Holder {
        //something
    }

    companion object {
        //something
    }
}

J'ai déjà lu que cet objet compagnon doit être utilisé si les paramètres/méthodes contenant sont étroitement liés à sa classe.

Mais pourquoi existe-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.

Existe-t-il une différence dans son cycle de vie "statique" (je suis issu du cycle de vie Java)]?

objectkotlincompanion-object
58
Poweranimal

Les objets peuvent implémenter des interfaces. Dans une classe, la définition d'un objet simple qui n'implémente aucune interface n'a aucun avantage dans la plupart des cas. Cependant, la définition de plusieurs objets qui implémentent différentes interfaces (par exemple, Comparator) peut être très utile.

En termes de cycle de vie, il n'y a pas de différence entre un objet compagnon et un objet nommé déclaré dans une classe.

33
yole

Il existe deux types différents de object utilise, expression et déclaration.

Expression d'objet

Une expression d'objet peut être utilisée lorsqu'une classe nécessite de légères modifications, mais il n'est pas nécessaire de créer une sous-classe entièrement nouvelle pour elle. Les classes internes anonymes en sont un bon exemple.

    button.setOnClickListener(object: View.OnClickListener() {
        override fun onClick(view: View) {
            // click event
        }
    })

Une chose à surveiller est que les classes internes anonymes peuvent accéder aux variables à partir de la portée englobante et que ces variables ne doivent pas nécessairement être final. Cela signifie qu'une variable utilisée dans une classe interne anonyme qui n'est pas considérée comme final peut changer de valeur de manière inattendue avant son accès.

Déclaration d'objet

Une déclaration d'objet est similaire à une déclaration de variable et ne peut donc pas être utilisée à droite d'une instruction d'affectation. Les déclarations d'objet sont très utiles pour implémenter le motif Singleton.

    object MySingletonObject {
        fun getInstance(): MySingletonObject {
            // return single instance of object
        }
    }

Et la méthode getInstance peut alors être invoquée comme ceci.

    MySingletonObject.getInstance()

Objet compagnon

Un objet compagnon est un type spécifique de déclaration d'objet qui permet à un objet d'agir de la même manière que des objets statiques dans d'autres langages (tels que Java). Ajouter companion à la déclaration d'objet permet d'ajouter la fonctionnalité "statique" à un objet même si le concept statique réel n'existe pas dans Kotlin. Voici un exemple de classe avec des méthodes d'instance et des méthodes associées.

 class MyClass {
        companion object MyCompanionObject {
            fun actsAsStatic() {
                // do stuff
            }
        }

       fun instanceMethod() {
            // do stuff
        }
    }

Invoquer la méthode d'instance ressemblerait à ceci.

    var myClass = MyClass()
    myClass.instanceMethod()

L'appel de la méthode de l'objet compagnon ressemblerait à ceci.

    MyClass.actsAsStatic()

Voir le Docs Kotlin pour plus d'informations.

43
Mike

Un objet, ou une déclaration d'objet, est initialisé paresseusement lors de son premier accès.

Un objet compagnon est initialisé lorsque la classe correspondante est chargée. Cela crée une essence "statique", bien que Kotlin ne prenne pas en charge les membres statiques de manière inhérente.

4
Supriya

L'objet compagnon existe parce que vous pouvez appeler les fonctions/propriétés des objets compagnons comme s'il s'agissait d'une méthode/champ statique Java. Et pourquoi votre Holder est autorisé, eh bien, il n'y a pas Il est parfois illégal de déclarer un objet imbriqué.

3
glee8e

Un objet compagnon est initialisé lorsque la classe est chargée (généralement la première fois qu'il est référencé par un autre code en cours d'exécution) alors que Les déclarations d'objet sont initialisées paresseusement lors de leur premier accès.

Veuillez vous référer à https://kotlinlang.org/docs/reference/object-declarations.html la section inférieure définit clairement la différence entre ces deux éléments.

0
Swati Singh