Héritage

L'héritage est un mécanisme fondamental de la POO qui permet à une classe (appelée classe fille ou sous-classe) d'hériter des champs et des méthodes d'une autre classe (appelée classe parent ou super-classe).

Cela favorise la réutilisation du code et évite les répétitions inutiles.

Étendre une Classe avec extends

En Java, nous utilisons le mot-clé extends pour indiquer qu'une classe hérite d'une autre :

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()
}

Le Constructeur et le Mot-clé super()

Si la super-classe a un constructeur qui accepte des paramètres, la sous-classe doit l'appeler explicitement dans son constructeur en utilisant super(...) comme toute première instruction :

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;
    }
}

Redéfinition des Méthodes (@Override)

Une sous-classe peut fournir sa propre implémentation spécifique pour une méthode héritée de la super-classe. Cette opération s'appelle la redéfinition (method overriding) et est indiquée par l'annotation @Override.

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

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

Le Modificateur protected

Le modificateur d'accès protected joue un rôle clé dans l'héritage. Contrairement à private, qui rend les membres visibles uniquement au sein de la même classe, protected permet l'accès aux champs et aux méthodes à la fois au sein du même paquet (package) et par toutes les sous-classes, même si elles se trouvent dans des paquets différents.

Accéder aux Membres du Parent avec super

En plus d'appeler le constructeur de la super-classe, le mot-clé super peut être utilisé au sein des méthodes de la sous-classe pour faire référence aux méthodes ou aux variables de la classe parent. Ceci est particulièrement utile lorsqu'une méthode est redéfinie, mais que l'on souhaite tout de même appeler le comportement d'origine du parent :

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.");
    }
}

Héritage Unique en Java

En Java, une classe peut étendre une seule classe (héritage unique). Il n'est pas permis d'hériter directement de plusieurs classes (héritage multiple), par exemple class Cat extends Animal, Mammal générera une erreur. Ce choix de conception évite les ambiguïtés connues sous le nom de "problème du diamant" (lorsque deux super-classes définissent la même méthode avec des implémentations différentes). Pour dépasser cette limite, Java introduit le concept d'Interfaces, que nous verrons dans le prochain module.

À vous de jouer