Ereditarietà in Java: extends, super e override

L'ereditarietà è riuso di tipo "è un"

L'ereditarietà permette a una nuova classe di basarsi su una esistente. La nuova classe, la sottoclasse, riceve automaticamente i campi e i metodi della superclasse, poi aggiunge o modifica ciò che le serve. La usi quando un tipo è una variante più specifica di un altro: un Dog è un Animal, un SavingsAccount è un BankAccount.

La scrivi con la parola chiave extends. Tutto ciò che è public o protected nella classe madre è disponibile nella figlia senza doverlo riscrivere.

class Animal {
    String name;

    Animal(String name) { this.name = name; }

    void eat() { System.out.println(name + " is eating"); }
}

class Dog extends Animal {
    Dog(String name) { super(name); }   // passa name ad Animal

    void bark() { System.out.println(name + " says woof"); }
}

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog("Rex");
        d.eat();    // ereditato da Animal
        d.bark();   // definito in Dog
    }
}

Dog non dichiara mai name né eat(), eppure li ha entrambi. È proprio questo il punto: il comportamento condiviso vive in un solo posto.

super: raggiungere la classe madre

Il costruttore di una sottoclasse deve assicurarsi che la classe madre sia inizializzata per prima. Lo fai con super(...), che chiama il costruttore della classe madre e deve essere la prima istruzione del costruttore della sottoclasse. Se lo ometti, Java inserisce in silenzio una chiamata al costruttore senza argomenti della classe madre, e se la classe madre non ne ha uno, il codice non compila.

class Account {
    double balance;

    Account(double opening) {
        balance = opening;
        System.out.println("Account opened with " + opening);
    }
}

class SavingsAccount extends Account {
    double rate;

    SavingsAccount(double opening, double rate) {
        super(opening);     // esegui prima il costruttore di Account
        this.rate = rate;
        System.out.println("Savings rate set to " + rate);
    }
}

public class Main {
    public static void main(String[] args) {
        new SavingsAccount(100.0, 0.05);
    }
}

L'output mostra che il costruttore della classe madre viene eseguito prima del corpo di quello della figlia: la costruzione scende dalla cima della gerarchia verso il basso.

Override dei metodi

Una sottoclasse può sostituire un metodo ereditato ridefinendolo con la stessa firma. Questo si chiama override, e dovresti sempre marcarlo con @Override. L'annotazione non è obbligatoria, ma fa verificare al compilatore che tu abbia davvero corrisposto a un metodo della classe madre: intercetta errori di battitura come tostring() al posto di toString(), che altrimenti creerebbero in silenzio un metodo completamente nuovo.

class Animal {
    String speak() { return "..."; }
}

class Cat extends Animal {
    @Override
    String speak() { return "meow"; }
}

class Cow extends Animal {
    @Override
    String speak() { return "moo"; }
}

public class Main {
    public static void main(String[] args) {
        Animal[] animals = { new Cat(), new Cow(), new Animal() };
        for (Animal a : animals) {
            System.out.println(a.speak());   // ognuno esegue la propria versione
        }
    }
}

Anche se l'array è di tipo Animal, ogni elemento esegue il proprio speak(). Java sceglie il metodo in base all'oggetto reale a runtime, non al tipo dichiarato della variabile: è la base del polimorfismo.

Chiamare la versione della classe madre con super.method()

Fare l'override non significa buttare via il lavoro della classe madre. Usa super.method() per eseguire la versione ereditata e poi aggiungere qualcosa:

class Logger {
    void log(String msg) { System.out.println("[log] " + msg); }
}

class TimestampLogger extends Logger {
    @Override
    void log(String msg) {
        super.log("at t=0 " + msg);   // riusa la classe madre, poi estendi
    }
}

public class Main {
    public static void main(String[] args) {
        new TimestampLogger().log("server started");
    }
}

Senza super., chiamare log dentro TimestampLogger.log richiamerebbe se stesso all'infinito. super. significa esplicitamente "la versione della classe madre".

Campi ereditati e accesso

Una sottoclasse vede i membri public e protected della classe madre ma non quelli private. I campi private esistono comunque nell'oggetto, e i metodi della classe madre possono usarli, ma la sottoclasse non può riferirsi a loro direttamente. Usa protected, uno dei modificatori di accesso di Java, quando vuoi dare accesso alle sottoclassi tenendo il membro nascosto al codice non correlato.

class Base {
    private int secret;      // invisibile alle sottoclassi
    protected int shared;    // visibile alle sottoclassi
}

class Derived extends Base {
    void demo() {
        shared = 5;          // OK
        // secret = 5;       // errore di compilazione: private in Base
    }
}

È anche per questo che il costruttore di una sottoclasse spesso deve chiamare super(...): è l'unico modo per inizializzare lo stato privato della classe madre.

Bloccare l'ereditarietà con final

A volte una classe non dovrebbe essere estesa affatto: String è final proprio per questo motivo. Marcare una classe come final vieta di crearne sottoclassi; marcare un metodo come final ne vieta l'override pur permettendo di estendere la classe.

final class Constants { }            // non può avere sottoclassi

class Config {
    final void load() { }            // le sottoclassi possono estendere Config
                                     // ma non possono fare l'override di load()
}

Usa final quando il comportamento di una classe deve essere garantito e immutabile in tutto il programma: è un segnale deliberato di "non estendere", non l'impostazione predefinita.

Una trappola comune: preferisci la composizione se non è "è un"

L'ereditarietà è allettante perché riutilizza codice, ma lega strettamente la figlia alla madre. Se la relazione non è un vero "è un", per esempio una Car che ha bisogno di un Engine, non scrivere Car extends Engine. Un'auto ha un motore, non è un motore. Rappresentalo invece con un campo (composizione):

class Car {
    private Engine engine = new Engine();   // Car HA-UN Engine

    void start() { engine.ignite(); }
}

Usa l'ereditarietà solo quando la sottoclasse è davvero una forma specializzata della superclasse e vuoi sia ereditarne sia sostituirne il comportamento.

Prossimo passo: le interfacce

L'ereditarietà con extends ti dà una sola classe madre e un'implementazione condivisa. Ma una classe può estendere una sola classe: come fai allora a dare una capacità comune a classi non correlate? È a questo che servono le interfacce: un contratto che molte classi possono implementare, ed è l'argomento della prossima pagina.