Ereditarietà

L'ereditarietà è un meccanismo fondamentale della OOP che consente a una classe (chiamata classe figlia o sottoclasse) di ereditare campi e metodi da un'altra classe (chiamata classe padre o superclasse).

Questo promuove il riutilizzo del codice ed evita ripetizioni non necessarie.

Estendere una Classe con extends

In Java, usiamo la parola chiave extends per indicare che una classe eredita da un'altra:

class Vehicle {
    protected int speed; // 'protected' rende il campo visibile alle sottoclassi

    public void honk() {
        System.out.println("Beep beep!");
    }
}

class Car extends Vehicle {
    // Car eredita automaticamente il campo speed e il metodo honk()
}

Il Costruttore e la Parola Chiave super()

Se la superclasse ha un costruttore che accetta parametri, la sottoclasse deve chiamarlo esplicitamente nel suo costruttore usando super(...) come primissima istruzione:

class Person {
    String name;

    public Person(String name) {
        this.name = name;
    }
}

class Student extends Person {
    int studentId;

    public Student(String name, int studentId) {
        super(name); // Richiama il costruttore di Person
        this.studentId = studentId;
    }
}

Sovrascrittura dei Metodi (@Override)

Una sottoclasse può fornire una propria implementazione specifica per un metodo ereditato dalla superclasse. Questa operazione si chiama sovrascrittura (method overriding) e viene indicata con l'annotazione @Override.

class Animal {
    public void makeSound() {
        System.out.println("Rumore generico");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Miao!");
    }
}

Il Modificatore protected

Il modificatore di accesso protected gioca un ruolo chiave nell'ereditarietà. A differenza di private, che rende i membri visibili solo all'interno della stessa classe, protected consente l'accesso ai campi e ai metodi sia all'interno dello stesso pacchetto (package) sia da parte di tutte le sottoclassi, anche se si trovano in pacchetti diversi.

Accedere ai Membri del Padre con super

Oltre a richiamare il costruttore della superclasse, la parola chiave super può essere usata all'interno dei metodi della sottoclasse per fare riferimento a metodi o variabili della classe padre. Questo è particolarmente utile quando un metodo viene sovrascritto, ma si desidera comunque richiamare il comportamento originale del genitore:

class Animal {
    public void sleep() {
        System.out.println("Zzz");
    }
}

class Cat extends Animal {
    @Override
    public void sleep() {
        super.sleep(); // Esegue il comportamento di Animal
        System.out.println("Il gatto fa le fusa mentre dorme.");
    }
}

Ereditarietà Singola in Java

In Java, una classe può estendere una sola classe (ereditarietà singola). Non è consentito ereditare direttamente da più classi (ereditarietà multipla), ad esempio class Cat extends Animal, Mammal genererà un errore. Questa scelta di design evita ambiguità note come "problema del diamante" (quando due superclassi definiscono lo stesso metodo con implementazioni diverse). Per superare questo limite, Java introduce il concetto di Interfacce, che vedremo nel prossimo modulo.

Prova tu