Héritage simple et multiniveau

Fait partie de la section Programmation Orientée Objet du Journey Java de Coddy — leçon 25 sur 87.

Jusqu'à présent, nous avons vu des classes étendre directement une classe parente. Mais l'héritage peut former différentes structures selon la manière dont les classes sont liées les unes aux autres. Explorons les deux principaux modèles : l'héritage simple et l'héritage multiniveau.

L'héritage simple est ce que nous avons utilisé jusqu'à présent. Une classe étend exactement une seule classe parente directement :

public class Animal { }
public class Dog extends Animal { }
public class Cat extends Animal { }

Ici, Dog et Cat héritent tous deux de Animal, mais ils n'héritent pas l'un de l'autre. Chaque enfant a un parent direct.

L'héritage multiniveau crée une chaîne où une classe en étend une autre, qui elle-même en étend une autre :

public class Animal {
    public void eat() {
        System.out.println("Eating");
    }
}

public class Mammal extends Animal {
    public void breathe() {
        System.out.println("Breathing");
    }
}

public class Dog extends Mammal {
    public void bark() {
        System.out.println("Barking");
    }
}

Dans cette chaîne, Dog hérite de Mammal, qui hérite de Animal. Un objet Dog a accès à toutes les méthodes de l'ensemble de la chaîne :

Dog dog = new Dog();
dog.eat();      // Provient de Animal
dog.breathe();  // Provient de Mammal
dog.bark();     // Provient de Dog

N'oubliez pas que Object se trouve au sommet de chaque chaîne. Ainsi, notre Dog possède en réalité quatre niveaux : Object -> Animal -> Mammal -> Dog. Le chaînage des constructeurs parcourt tous ces niveaux lors de la création d'un nouvel objet.

Défi

Facile

Construisons une hiérarchie de transport qui démontre à la fois les modèles d'héritage simple et multiniveau. Vous allez créer une chaîne de classes où chaque niveau ajoute de nouvelles capacités, montrant comment les méthodes sont héritées à travers plusieurs niveaux.

Vous organiserez votre code sur quatre fichiers :

Vehicle.java : Créez la classe de base au sommet de votre hiérarchie. Chaque véhicule doit avoir :
- Un champ privé pour brand (String)
- Un constructeur qui accepte la marque
- Une méthode getBrand() qui retourne la marque
- Une méthode move() qui affiche : [brand] is moving
LandVehicle.java : Créez une classe qui étend Vehicle, représentant le niveau intermédiaire de votre chaîne multiniveau. Les véhicules terrestres ajoutent un comportement spécifique au sol :
- Un champ privé pour wheels (int)
- Un constructeur qui prend la marque et les roues, en utilisant super(brand) pour la partie parente
- Une méthode getWheels() qui retourne le nombre de roues
- Une méthode honk() qui affiche : [brand] honks!
Car.java : Créez une classe qui étend LandVehicle, complétant votre chaîne d'héritage à trois niveaux. Les voitures ajoutent leurs propres caractéristiques spécialisées :
- Un champ privé pour model (String)
- Un constructeur qui prend la marque, les roues et le modèle, en utilisant super(brand, wheels)
- Une méthode getModel() qui retourne le modèle
- Une méthode displayInfo() qui affiche : [brand] [model] with [wheels] wheels
Main.java : Démontrez comment un objet Car a accès aux méthodes des trois niveaux de la hiérarchie. Vous recevrez trois entrées : brand (String), wheels (int) et model (String). Créez une Car et appelez ces méthodes dans l'ordre :
- move() - héritée de Vehicle (grand-parent)
- honk() - héritée de LandVehicle (parent)
- displayInfo() - définie dans Car elle-même

Vous recevrez trois entrées : le nom de la marque, le nombre de roues et le nom du modèle.

Votre sortie devrait afficher trois lignes démontrant comment l'objet Car peut utiliser des méthodes de chaque niveau de sa chaîne d'héritage - du niveau supérieur Vehicle jusqu'à sa propre classe !

Aide-mémoire

Java prend en charge différentes structures d'héritage. Les deux modèles principaux sont l'héritage simple et l'héritage multiniveau.

L'héritage simple se produit lorsqu'une classe étend exactement une seule classe parente directement :

public class Animal { }
public class Dog extends Animal { }
public class Cat extends Animal { }

Dog et Cat héritent tous deux de Animal, mais pas l'un de l'autre.

Héritage multiniveau crée une chaîne où une classe étend une autre classe, qui elle-même étend une autre classe :

public class Animal {
    public void eat() {
        System.out.println("Eating");
    }
}

public class Mammal extends Animal {
    public void breathe() {
        System.out.println("Breathing");
    }
}

public class Dog extends Mammal {
    public void bark() {
        System.out.println("Barking");
    }
}

Dans l'héritage multiniveau, une classe enfant a accès à toutes les méthodes de l'ensemble de la chaîne d'héritage :

Dog dog = new Dog();
dog.eat();      // De Animal
dog.breathe();  // De Mammal
dog.bark();     // De Dog

Chaque hiérarchie de classes possède Object à son sommet. Le chaînage des constructeurs parcourt tous les niveaux lors de la création d'un nouvel objet.

Essayez vous-même

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Lire les entrées
        String brand = scanner.nextLine();
        int wheels = scanner.nextInt();
        scanner.nextLine(); // consommer le saut de ligne
        String model = scanner.nextLine();
        
        // TODO: Créer un objet Car avec les valeurs d'entrée
        
        // TODO: Appeler move() - hérité de Vehicle (grand-parent)
        
        // TODO: Appeler honk() - hérité de LandVehicle (parent)
        
        // TODO: Appeler displayInfo() - défini dans Car lui-même
    }
}