Kotlin Academy · Lezione

Delega e ereditarietà

Scelga la composizione

Delega e ereditarietà è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.

Due modi per riutilizzare il comportamento

Ereditarietà e delegazione consentono entrambe di riutilizzare il comportamento. L'ereditarietà afferma che una classe è un tipo di un'altra. La delegazione afferma che una classe ha un collaboratore a cui inoltra le chiamate.

Il consiglio classico è preferire la composizione all'ereditarietà.

Esempio di ereditarietà

Con l'ereditarietà, una sottoclasse estende una classe base ed esegue l'override dei membri. In Kotlin, la classe base deve essere open.

open class Animal {
    open fun sound() = "..."
}

class Dog : Animal() {
    override fun sound() = "woof"
}

fun main() {
    println(Dog().sound())
}

Esempio di delegazione

Lo stesso riutilizzo con la delegazione: il comportamento risiede in un membro a cui la classe inoltra le chiamate.

interface Sound { fun sound(): String }
class Bark : Sound { override fun sound() = "woof" }

class Dog(s: Sound) : Sound by s

fun main() {
    println(Dog(Bark()).sound())
}

La classe base fragile

L'ereditarietà lega strettamente una sottoclasse ai dettagli interni della classe padre. Una modifica nella classe base può causare la rottura silenziosa delle sottoclassi: è il problema della classe base fragile. La delegazione dipende solo dall'interfaccia.

Incapsulamento

Una sottoclasse può accedere ai membri protected e sottoporre a override gli hook, sbirciando all'interno della classe padre. Una classe che delega vede solo l'interfaccia pubblica, preservando l'incapsulamento.

interface Counter { fun increment(): Int }

class SimpleCounter : Counter {
    private var n = 0
    override fun increment(): Int { n++; return n }
}

class GuardedCounter(private val c: Counter) : Counter by c {
    override fun increment(): Int {
        println("incrementing")
        return c.increment()
    }
}

fun main() {
    val g = GuardedCounter(SimpleCounter())
    println(g.increment())
    println(g.increment())
}

Flessibilità a runtime

L'ereditarietà fissa la classe padre in fase di compilazione. La delegazione consente di inserire implementazioni diverse a runtime, facilitando i test con fake.

interface Clock { fun now(): Int }
class RealClock : Clock { override fun now() = 100 }
class FakeClock : Clock { override fun now() = 0 }

class Timer(c: Clock) : Clock by c

fun main() {
    println(Timer(RealClock()).now())
    println(Timer(FakeClock()).now()) // easy to test
}

Più comportamenti

Una classe può estendere una sola classe padre, ma può delegare a molte interfacce. La delegazione si adatta alla combinazione di più funzionalità.

interface Walk { fun walk() = "walking" }
interface Swim { fun swim() = "swimming" }
class Walker : Walk
class Swimmer : Swim

class Amphibian : Walk by Walker(), Swim by Swimmer()

fun main() {
    val a = Amphibian()
    println(a.walk() + ", " + a.swim())
}

Quando usare l'ereditarietà

L'ereditarietà è ancora la scelta giusta per una vera relazione is-a con una gerarchia stabile e progettata per l'estensione: famiglie di tipi sealed, classi base dei framework e polimorfismo su un tipo astratto condiviso.

sealed class Shape
class Circle(val r: Double) : Shape()
class Square(val s: Double) : Shape()

fun area(shape: Shape) = when (shape) {
    is Circle -> 3.14 * shape.r * shape.r
    is Square -> shape.s * shape.s
}

fun main() {
    println(area(Circle(2.0)))
}

Quando usare la delegazione

Scelga la delegazione quando desidera:

Riutilizzare il comportamento tra tipi non correlati
Combinare più funzionalità
Mantenere basso l'accoppiamento e semplificare i test
Avvolgere e decorare implementazioni esistenti

Confronto diretto

Ereditarietà: una classe padre, accoppiamento stretto, fissa in fase di compilazione, is-a. Delegazione: molti collaboratori, accoppiamento debole, sostituibile a runtime, has-a. Kotlin rende la delegazione economica con by, spostando l'equilibrio verso la composizione.

Una scelta predefinita pratica

Una buona regola: inizi dalla delegazione. Passi all'ereditarietà solo quando emerge una gerarchia is-a autentica e stabile. In questo modo i progetti restano flessibili e resistenti ai cambiamenti.

Verifica rapida

Verifichi la Sua comprensione della delegazione rispetto all'ereditarietà.

Riepilogo

Ha confrontato i due approcci:

Ereditarietà: is-a, una sola classe padre, accoppiamento stretto
Delegazione: has-a, molti collaboratori, accoppiamento debole
Preferisca la composizione; usi l'ereditarietà per gerarchie is-a stabili

Prossimo argomento: pattern decorator pratici con la delegazione.

Domande Frequenti

La lezione «Delega e ereditarietà» è gratuita?

Sì — il testo completo di «Delega e ereditarietà» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.

Cosa imparerò in «Delega e ereditarietà»?

Scelga la composizione Eserciti Kotlin Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Kotlin Academy?

Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Delega e ereditarietà»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Kotlin Academy?

Sì. Ogni lezione Kotlin Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Kotlin Academy