Espressioni oggetto

Fa parte della sezione Programmazione orientata agli oggetti del percorso Kotlin di Coddy. Lezione 15 di 57.

Un’espressione oggetto crea un oggetto monouso di una classe senza nome, proprio dove serve. Si scrive object : Type { ... } e di solito implementa un’interfaccia. Un’interfaccia elenca i metodi senza specificare come funzionano; il capitolo 5 tratta le interfacce in modo approfondito:

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

All’interno di main:

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

Output:

Good morning, Ada.

Una dichiarazione di oggetto esiste una sola volta. Un'espressione oggetto viene valutata ogni volta che il suo codice viene eseguito e ogni esecuzione crea un nuovo oggetto. Può leggere e modificare le variabili locali che la circondano:

interface Counter {
    fun next(): Int
}

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

All'interno di main:

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

Output:

10 11 1

Un uso comune consiste nel delegare il comportamento a una funzione di libreria. sortedWith accetta un Comparator, un'interfaccia il cui metodo compare(a, b) restituisce un numero negativo quando a viene prima, zero in caso di parità e un numero positivo altrimenti:

Dentro 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))

Output:

[fig, kiwi, apple, banana]

Un'espressione oggetto senza supertipo raggruppa alcuni valori in un oggetto locale; le sue proprietà possono essere usate all'interno della stessa funzione. Quando un'interfaccia ha un solo metodo, una lambda è spesso più breve di un'espressione oggetto. Le espressioni oggetto sono adatte quando ci sono diversi metodi o uno stato da mantenere.

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 }   // forma lambda

Sfida

Facile

L'interfaccia Validator ha un metodo, check(text), che restituisce un messaggio di errore oppure null quando il testo supera il controllo. Completa la funzione rules(minLength) in modo che restituisca tre validatori creati con espressioni oggetto, in quest'ordine: il testo deve contenere almeno minLength caratteri (too short), contenere una cifra (needs a digit) e non contenere spazi (no spaces allowed).

Il codice fornito legge la lunghezza minima e poi una password per riga. Stampa ok oppure tutti i messaggi di errore relativi a quella password, uniti con ; .

Il tuo codice va inserito in Rules.kt e Validator.kt. Main.kt contiene il codice di input/output fornito e non può essere modificato.

Provalo tu

fun main() {
    // Codice di input/output fornito: lascialo così com'è
    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("; "))
    }
}