Risposta

Kotlin supporta i parametri di eredità tramite la parola chiave open, ma la raccomandazione principale del linguaggio è di optare per la composizione invece che per l'ereditarietà. Questo consente di creare sistemi più flessibili ed estensibili, evitando la fragilità delle gerarchie e i problemi legati all'ereditarietà profonda.

Composizione consiste nel includere un oggetto del tipo necessario come campo della classe e delegare a esso il lavoro, invece di ereditare la sua implementazione. Kotlin facilita il pattern di delega tramite la parola chiave by, consentendo di delegare automaticamente l'implementazione delle interfacce agli oggetti.

Esempio di pattern di delega:

interface Logger {
    fun log(message: String)
}

class ConsoleLogger : Logger {
    override fun log(message: String) = println(message)
}

class Service(private val logger: Logger) : Logger by logger {
    fun doAction() {
        log("Azione completata")
    }
}

fun main() {
    val service = Service(ConsoleLogger())
    service.doAction() // Mostrerà: Azione completata
}

Questo approccio semplifica il riutilizzo del codice e rende la logica più modulare.

Domanda ingannevole

"Può una data class ereditare da un'altra classe, ad esempio un'astratta?"

• Risposta: data class in Kotlin non può ereditare da un'altra classe (eccetto le interfacce), poiché data class è sempre final. L'eccezione sono le interfacce, che possono essere implementate.

Esempio:

abstract class Base(val name: String)
data class Derived(val age: Int, val name: String) : Base(name) // Errore di compilazione: data class non può estendere la classe Base

Ma è possibile:

interface User

data class Admin(val name: String, val rights: List<String>) : User

Esempi di errori reali dovuti alla mancanza di conoscenza delle complessità dell'argomento

---

Storia

In un progetto è stato deciso di ereditare diversi servizi da una classe astratta comune per implementare la logica ripetitiva. Alla fine, si sono creati molti livelli di ereditarietà, complicando il debug e causando problemi nei test. Dopo il passaggio alla composizione e delega (tramite interfacce e dependency injection), si è riusciti a semplificare il codice, rendendolo più modulare e aumentando la copertura dei test.

---

Storia

Un programmatore alle prime armi ha cercato di estendere una data class con un'altra classe per aggiungere funzionalità comuni. Il codice non si compilava, ma il programmatore non riusciva a capire a lungo il motivo (le limitazioni della data class in Kotlin).

---

Storia

In un progetto con una logica di registrazione complessa, si decise di estrarre la funzionalità di registrazione in una classe base. Tuttavia, con la crescita del sistema, alcuni servizi richiedevano un'implementazione diversa della registrazione. È stato necessario fare refactoring utilizzando l'interfaccia Logger e la composizione tramite delega, il che ha semplificato notevolmente l'architettura.