TOC

Objets à Kotlin

Objets à Kotlin

1. introduction

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

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

2. Objets à Kotlin

Dans Kotlin, comme dans presque tous les langages JVM, il y a le concept declass au cœur du modèle de programmation orientée objet. Kotlin introduces the concept of an object on top of that.

Alors que aclass décrit des structures qui peuvent être instanciées à volonté et autorise autant d'instances que nécessaire,an object instead represents a single static instance, et ne peut jamais avoir plus ou moins que cette instance.

Ceci est utile pour diverses techniques, y compris les objets singleton et la mise en package simple des fonctionnalités d'encapsulation: 

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

assertEquals(42, SimpleSingleton.answer)
assertEquals("Hello, world!", SimpleSingleton.greet("world"))

Objects also offer full support for visibility modifiers, 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,objects can extend classes and implement interfaces. Ce faisant, il s’agit bien d’instances singleton de classes parent, 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 que la définition standard deobject, 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. Whilst it can have a name, it doesn’t need to have one, auquel cas il porte automatiquement le nomCompanion: 

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

Companion objects allow their members to be accessed from inside the companion class without specifying the name.

Dans le même temps, les membres visibles sont accessibles de l’extérieur de la classe s’ils sont précédés du 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

The main use for companion objects is to replace static fields/methods known from 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 statiquestaticField n’est pas facilement accessible à partir du code Java.

Adding this annotation generates the field exactly as needed for a standard static field, allowing for full interoperability from Java if necessary.

Cela signifie que ce qui précède génère une méthodestaticgetStaticField() sur la classeStaticClass.

5. Conclusion

Les objets dans Kotlin ajoutent une couche supplémentaire que nous pouvons utiliser, rationalisant davantage notre code et facilitant son développement.

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

Comme toujours, des extraits de code peuvent être trouvés surover on GitHub.

Related