Expressions d’objets

Fait partie de la section Programmation orientée objet du Journey Kotlin de Coddy. Leçon 15 sur 57.

Une expression d’objet crée un objet unique d’une classe sans nom, exactement là où il est nécessaire. Elle s’écrit object : Type { ... } et implémente généralement une interface. Une interface répertorie des méthodes sans indiquer comment elles fonctionnent le chapitre 5 traite des interfaces en profondeur :

interface Greeter {
    fun greet(name: String): String
}

À l’intérieur de main:

val polite = object : Greeter {
    override fun greet(name: String) = "Good morning, $name."
}
println(polite.greet("Ada"))

Sortie :

Good morning, Ada.

Une déclaration d’objet n’existe qu’une seule fois. Une expression d’objet est évaluée chaque fois que son code s’exécute, et chaque exécution crée un nouvel objet. Elle peut lire et modifier les variables locales qui l’entourent :

interface Counter {
    fun next(): Int
}

fun counterFrom(start: Int): Counter {
    var current = start
    return object : Counter {
        override fun next() = current++
    }
}

À l’intérieur de main :

val a = counterFrom(10)
val b = counterFrom(1)
println("${a.next()} ${a.next()} ${b.next()}")

Sortie :

10 11 1

Une utilisation courante consiste à transmettre un comportement à une fonction de bibliothèque. sortedWith prend un Comparator, une interface dont la méthode compare(a, b) renvoie un nombre négatif lorsque a vient en premier, zéro en cas d’égalité et un nombre positif dans le cas contraire :

Dans main :

val words = listOf("kiwi", "fig", "banana", "apple")
val byLength = object : Comparator<String> {
    override fun compare(a: String, b: String) = a.length - b.length
}
println(words.sortedWith(byLength))

Résultat :

[fig, kiwi, apple, banana]

Une expression d’objet sans supertype regroupe quelques valeurs dans un objet local ses propriétés peuvent être utilisées à l’intérieur de la même fonction. Lorsqu’une interface possède une seule méthode, une lambda est souvent plus concise qu’une expression d’objet. Les expressions d’objet conviennent lorsqu’il y a plusieurs méthodes ou un état à conserver.

val size = object {
    val width = 3
    val height = 4
}
println(size.width * size.height)                    // 12

val byLength = Comparator<String> { a, b -> a.length - b.length }   // forme lambda

Défi

Facile

L’interface Validator possède une méthode, check(text), qui renvoie un message d’erreur ou null lorsque le texte est valide. Complétez la fonction rules(minLength) afin qu’elle renvoie trois validateurs créés avec des expressions objet, dans cet ordre : le texte doit comporter au moins minLength caractères (too short), contenir un chiffre (needs a digit) et ne contenir aucun espace (no spaces allowed).

Le code fourni lit la longueur minimale, puis un mot de passe par ligne. Il affiche ok, ou chaque message d’erreur de ce mot de passe, assemblé avec ; .

Votre code doit être placé dans Rules.kt et Validator.kt. Main.kt contient le code fourni pour les entrées et les sorties et ne peut pas être modifié.

Essayez vous-même

fun main() {
    // Code d'entrée/sortie fourni : le garder tel quel
    val input = generateSequence(::readLine).toList()
    val checks = rules(input[0].toInt())
    for (password in input.drop(1)) {
        val problems = checks.mapNotNull { it.check(password) }
        println(if (problems.isEmpty()) "ok" else problems.joinToString("; "))
    }
}