Companion Object en Kotlin

Introduction :

Dans cet article, nous allons explorer en détail la notion de “companion object” en Kotlin et apprendre comment l’utiliser efficacement à travers des exemples de code. Kotlin, le langage de programmation moderne et multi-plateforme, propose des fonctionnalités avancées pour simplifier et améliorer le développement d’applications.
L’une de ces fonctionnalités est le “companion object“, qui permet de définir des méthodes et des propriétés statiques pour une classe.

Qu’est-ce qu’un Companion Object ?

En Kotlin, les classes ne peuvent pas avoir de membres statiques (méthodes ou propriétés) comme en Java. Pour contourner cette limitation, Kotlin propose les Companion Objects, qui sont des objets singleton internes à une classe.
Ces objets permettent de définir des méthodes et propriétés accessibles sans créer une instance de la classe parente, similaires aux membres statiques en Java.

Un “companion object” est un objet singleton associé à une classe, permettant d’accéder à ses membres sans avoir besoin d’instancier la classe elle-même. En d’autres termes, il permet de créer des méthodes et des propriétés statiques pour une classe, de manière similaire à ce que l’on peut faire en Java avec les membres “static”.

Déclaration et utilisation d’un Companion Object

Pour déclarer un Companion Object, utilisez le mot-clé companion object à l’intérieur d’une classe. Voici un exemple simple :

class MyClass {
    companion object {
        val myProperty = "Je suis une propriété statique"
        fun myMethod() = "Je suis une méthode statique"
    }
}


Dans cet exemple, nous avons défini un companion object contenant une propriété myProperty et une méthode myMethod. Pour accéder à ces membres, il suffit d’utiliser le nom de la classe suivi d’un point et du nom du membre :

fun main() {
    println(MyClass.myProperty) // Affiche : Je suis une propriété statique
    println(.myMethod()) // Affiche : Je suis une méthode statique
}

Autre exemple :

class MyClass {
    companion object {
        const val MAX_COUNT = 10
        
        fun doSomething() {
            // faire quelque chose ici
        }
    }
}


Dans l’exemple ci-dessus, la classe MyClass définit un companion object qui contient une constante MAX_COUNT et une méthode doSomething(). Ces éléments peuvent être utilisés à partir de l’extérieur de la classe en utilisant le nom de la classe comme préfixe, comme ceci:

val maxCount = MyClass.MAX_COUNT
MyClass.doSomething()


Notez que le companion object peut être utilisé sans avoir besoin d’instancier la classe MyClass.

Companion object et interfaces

Un companion object peut également être utilisé pour implémenter des interfaces. Cela peut être utile pour ajouter des fonctionnalités à une classe sans avoir à modifier sa signature.

interface MyInterface {
    companion object {
        fun create(): MyInterface {
            return object : MyInterface {
                // implémenter l'interface ici
            }
        }
    }
}


Dans l’exemple ci-dessus, l’interface MyInterface définit un companion object qui implémente la méthode create(). Cette méthode renvoie une instance de l’interface MyInterface.

L’utilisation de cette méthode est la suivante:

val myInterface = MyInterface.create()

Companion object et extension de fonction

Un companion object peut également être utilisé pour étendre une classe avec des fonctions utilitaires sans avoir à utiliser une fonction d’extension.

class MyClass {
    companion object {
        fun parse(s: String): MyClass {
            // faire quelque chose ici
        }
    }
}

val myClass = MyClass.parse("exemple")

Dans l’exemple ci-dessus, la classe MyClass définit un companion object qui contient une méthode parse(). Cette méthode peut être utilisée directement en utilisant le nom de la classe MyClass comme préfixe.

Conclusion

Le companion object est un élément très utile de la programmation en Kotlin. Il permet de créer des objets associés à une classe qui peuvent être utilisés sans avoir à instancier la classe elle-même. Le companion object peut être utilisé pour définir des constantes, des méthodes utilitaires, pour implémenter des interfaces et pour étendre des classes avec des fonctions utilitaires.

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Retour en haut
%d blogueurs aiment cette page :