Objets à Kotlin

1. Introduction

Kotlin a emprunté de nombreuses idées à d'autres langues; l'une de ces constructions est l' objet.

Dans cet article rapide, nous verrons ce que sont les objets et comment les utiliser.

2. Objets dans Kotlin

Dans Kotlin, comme dans presque tous les langages JVM, il y a le concept d'une classe au cœur du modèle de programmation orientée objet. Kotlin introduit le concept d' objet en plus de cela.

Alors qu'une classe décrit des structures qui peuvent être instanciées au fur et à mesure et autorise autant d'instances que nécessaire, un objet représente à la place une seule instance statique et ne peut jamais avoir plus ou moins que cette seule instance.

Ceci est utile pour diverses techniques, y compris les objets singleton et le simple empaquetage de fonctionnalités pour l'encapsulation:

object SimpleSingleton { val answer = 42; fun greet(name: String) = "Hello, $name!" } assertEquals(42, SimpleSingleton.answer) assertEquals("Hello, world!", SimpleSingleton.greet("world"))

Les objets offrent également une prise en charge complète des modificateurs de visibilité , permettant le masquage et l'encapsulation des données comme avec toute autre classe:

object Counter { private var count: Int = 0 fun currentCount() = count fun increment() { ++count } } Counter.increment() println(Counter.currentCount()) println(Counter.count) // this will fail to compile

De plus, les objets peuvent étendre les classes et implémenter des interfaces . Ce faisant, ce sont en fait des instances singleton de classes parentes, exactement comme prévu.

Cela peut être très utile dans les cas où nous avons une implémentation sans état et où il n'est pas nécessaire de créer une nouvelle instance à chaque fois - par exemple, Comparator:

object ReverseStringComparator : Comparator { override fun compare(o1: String, o2: String) = o1.reversed().compareTo(o2.reversed()) } val strings = listOf("Hello", "World") val sortedStrings = strings.sortedWith(ReverseStringComparator)

3. Qu'est-ce qu'un objet compagnon?

Les objets compagnons sont essentiellement les mêmes qu'une définition d' objet standard , avec seulement quelques fonctionnalités supplémentaires pour faciliter le développement.

Un objet compagnon est toujours déclaré à l'intérieur d'une autre classe. Bien qu'il puisse avoir un nom, il n'en a pas besoin , auquel cas il porte automatiquement le nom Companion :

class OuterClass { companion object { // Equivalent to "companion object Companion" } }

Les objets compagnons permettent d'accéder à leurs membres depuis l'intérieur de la classe compagnon sans en spécifier le nom .

Dans le même temps, les membres visibles sont accessibles depuis l'extérieur de la classe lorsqu'ils sont préfixés par le nom de la classe:

class OuterClass { companion object { private val secret = "You can't see me" val public = "You can see me" } fun getSecretValue() = secret } assertEquals("You can see me", OuterClass.public) assertEquals("You can't see me", OuterClass.secret) // Cannot access 'secret'

4. Champs statiques

L'utilisation principale des objets compagnons est de remplacer les champs / méthodes statiques connus de Java . Cependant, ces champs ne sont pas générés automatiquement en tant que tels dans le fichier de classe résultant.

Si nous avons besoin qu'ils soient générés, nous devons utiliser l' annotation @JvmStatic sur le champ à la place, qui générera alors le bytecode comme prévu:

class StaticClass { companion object { @JvmStatic val staticField = 42 } }

Sans cela, le champ statique staticField n'est pas facilement accessible à partir du code Java.

L'ajout de cette annotation génère le champ exactement comme nécessaire pour un champ statique standard, permettant une interopérabilité totale à partir de Java si nécessaire .

Cela signifie que ce qui précède génère une méthode statique getStaticField () sur la classe StaticClass .

5. Conclusion

Les objets dans Kotlin ajoutent toute une couche supplémentaire que nous pouvons utiliser, rationalisant davantage notre code et le rendant plus facile à développer.

Les objets compagnons vont ensuite encore plus loin, permettant un code plus propre, plus facile à gérer et à utiliser.

Comme toujours, des extraits de code peuvent être trouvés sur over sur GitHub.