Comprendre l’héritage en Java : single, multiple et extends

Voilà, débutants en programmation Java, aujourd’hui on part à l’aventure pour comprendre l’un des concepts fondamentaux du langage : l’héritage. Préparez-vous à plonger dans les relations « is-a », le single inheritance (l’héritage simple) et le multiple inheritance (l’héritage multiple). Et bien sûr, on ne pourra pas passer à côté du mot-clé extends , qui est au cœur de tout ça. Alors, accrochez-vous, on va essayer de rendre ça clair comme de l’eau de roche ! (Quoique, l’eau de roche, c’est plutôt trouble, mais vous avez compris l’idée.)

Introduction à l’héritage en Java

Commençons par définir ce qu’est l’héritage en Java. C’est un concept de programmation qui permet d’établir des relations « is-a » (est un) entre différentes catégories. En d’autres termes, ça nous permet de créer des catégories plus spécifiques à partir de catégories plus génériques. La catégorie spécifique « est un » type de la catégorie générique. (C’est comme dire qu’un berger allemand est un type de chien, ou qu’une Ferrari est un type de voiture.)

Ces relations « is-a » peuvent s’étendre sur plusieurs niveaux, créant des catégories de plus en plus spécifiques. Par exemple, on peut avoir une catégorie « Véhicule », avec « Voiture » et « Camion » comme sous-catégories. Ensuite, « Break » pourrait être une sous-catégorie de « Voiture », et « Camion-poubelle » une sous-catégorie de « Camion ». Vous visualisez bien la hiérarchie ?

Single Inheritance vs Multiple Inheritance

L’exemple ci-dessus illustre le single inheritance (héritage simple), où une catégorie enfant hérite d’une seule catégorie parent immédiate. En revanche, le multiple inheritance (héritage multiple) permettrait à une catégorie enfant d’hériter de deux ou plusieurs catégories parents immédiates. (Imaginez un aérogare qui pourrait hériter à la fois de « Véhicule terrestre » et « Véhicule aquatique », par exemple.)

Java supporte le single inheritance via l’extension de classes, mais ne permet pas le multiple inheritance.

Eh oui, Java a fait le choix de ne pas supporter le multiple inheritance au niveau des classes. Vous pouvez facilement repérer ce type d’héritage grâce à la présence d’un « motif en diamant » dans la hiérarchie des classes. (Un diamant, comme dans l’exemple avec « Véhicule », « Véhicule terrestre », « Véhicule aquatique » et « Aérogare ».)

Comment utiliser le mot-clé « extends » en Java

Java utilise le mot-clé extends pour établir les relations d’héritage entre les classes. Quand on l’utilise, extends spécifie qu’une classe est la classe enfant (sous-classe) d’une autre classe, qui devient alors la classe parent (super-classe). Voici quelques exemples :

class Vehicle { /* déclarations des membres */ }
class Car extends Vehicle { /* hérite des membres accessibles de Vehicle, et ajoute ses propres membres */ }

class Account { /* déclarations des membres */ }
class SavingsAccount extends Account { /* hérite des membres accessibles de Account, et ajoute ses propres membres */ }

Le mot-clé extends est placé après le nom de la classe, suivi du nom de la classe parent. Dans ces exemples, Car est une sous-classe spécialisée de Vehicle , et SavingsAccount est une sous-classe spécialisée de Account . (Vous voyez le trottoir ? Les relations « is-a » sont bien respectées.)

Notez qu’il est impossible de spécifier plusieurs classes parents après extends , car Java ne supporte pas le multiple inheritance au niveau des classes. (Désolé les amateurs de motifs en diamant, il va falloir se contenter du single inheritance pour l’instant.)

Héritage des membres de classe

Les classes enfants héritent des champs (fields) et des méthodes accessibles de leurs classes parents, ainsi que de leurs ancêtres plus lointains. Cependant, elles n’héritent jamais des constructeurs. (Parce que construire une sous-classe, c’est quand même un travail sur mesure, vous comprenez ?)

Les classes enfants doivent donc déclarer leurs propres constructeurs. Et bien sûr, elles peuvent aussi déclarer leurs propres champs et méthodes pour se différencier de leurs parents. (Un peu comme les enfants dans la vraie vie, en fait.)

Regardons un exemple concret avec la classe Account :

class Account {
    private String name;
    private long amount;

    Account(String name, long amount) {
        this.name = name;
        setAmount(amount);
    }

    void deposit(long amount) {
        this.amount += amount;
    }

    String getName() {
        return name;
    }

    long getAmount() {
        return amount;
    }

    void setAmount(long amount) {
        this.amount = amount;
    }
}

Cette classe représente un compte bancaire générique, avec un nom et un montant initial définis dans le constructeur. Elle permet aussi de faire des dépôts. (Pour les retraits, on peut juste déposer des montants négatifs, mais on va ignorer cette possibilité pour l’instant.)

Ensuite, voici la classe SavingsAccount qui hérite de Account :

class SavingsAccount extends Account {
    SavingsAccount(long amount) {
        super("savings", amount);
    }
}

Cette classe est assez simple, car elle n’a pas besoin de déclarer de nouveaux champs ou méthodes. Mais elle doit quand même déclarer un constructeur qui initialise les champs hérités de la classe parent Account . C’est ce que fait le mot-clé super , suivi des arguments pour le constructeur parent.

Et maintenant, jetons un œil à la classe CheckingAccount , qui étend aussi Account :

class CheckingAccount extends Account {
    CheckingAccount(long amount) {
        super("checking", amount);
    }

    void withdraw(long amount) {
        setAmount(getAmount() - amount);
    }
}

Cette fois, CheckingAccount est un peu plus élaborée, avec une méthode withdraw() qui permet de faire des retraits. Vous remarquerez les appels à setAmount() et getAmount() , qui sont hérités de la classe Account . (On ne peut pas accéder directement au champ amount déclaré private dans Account , du coup on passe par les méthodes d’accès.)

Comprendre la hiérarchie des classes en Java

Pour vous permettre de tester cette hiérarchie de classes, j’ai créé une application AccountDemo . Voici le code source :

class AccountDemo {
    public static void main(String[] args) {
        SavingsAccount sa = new SavingsAccount(10000);
        System.out.println("account name: " + sa.getName());
        System.out.println("initial amount: " + sa.getAmount());
        sa.deposit(5000);
        System.out.println("new amount after deposit: " + sa.getAmount());

        CheckingAccount ca = new CheckingAccount(20000);
        System.out.println("account name: " + ca.getName());
        System.out.println("initial amount: " + ca.getAmount());
        ca.deposit(6000);
        System.out.println("new amount after deposit: " + ca.getAmount());
        ca.withdraw(3000);
        System.out.println("new amount after withdrawal: " + ca.getAmount());
    }
}

La méthode main() commence par démontrer la classe SavingsAccount , puis CheckingAccount . Après avoir compilé tous les fichiers source, vous devriez obtenir la sortie suivante :

account name: savingsinitial amount: 10000new amount after deposit: 15000account name: checkinginitial amount: 20000new amount after deposit: 26000new amount after withdrawal: 23000

Facile, non ? (Bon, je vous l’accorde, ce n’était pas le plus compliqué des exemples, mais c’est un bon début pour comprendre l’héritage en Java.)

Méthode overriding vs méthode overloading

Une sous-classe peut remplacer (override) une méthode héritée, de sorte que sa propre version de la méthode sera appelée à la place. Une méthode de remplacement doit avoir le même nom, la même liste de paramètres et le même type de retour que la méthode remplacée.

Pour illustrer cela, j’ai déclaré une méthode print() dans la classe Vehicle :

class Vehicle {
    void print() {
        System.out.println("Je suis un véhicule.");
    }
}

class Car extends Vehicle {
    void print() {
        System.out.println("Je suis une voiture.");
    }
}

Ici, la méthode print() de Car remplace celle héritée de Vehicle . Donc, si vous créez une instance de Car et appelez print() , vous verrez « Je suis une voiture. » affiché.

Cela ne doit pas être confondu avec le method overloading (surcharge de méthode), qui consiste à déclarer plusieurs méthodes avec le même nom, mais des listes de paramètres différentes. Par exemple :

class MathUtils {
    int sum(int a, int b) {
        return a + b;
    }

    int sum(int a, int b, int c) {
        return a + b + c;
    }
}

Dans cet exemple, les deux méthodes sum() sont différentes car elles ont des listes de paramètres différentes. Le compilateur Java peut déterminer quelle méthode appeler en fonction des arguments fournis.

Conseils aux développeurs

Voilà, vous avez maintenant une bonne compréhension des bases de l’héritage en Java, du single inheritance, du mot-clé extends et de la hiérarchie des classes. N’oubliez pas que l’héritage est un outil puissant, mais qu’il faut l’utiliser avec précaution pour éviter de créer des hiérarchies trop complexes et difficiles à maintenir.

Ah, et une dernière chose : si vous voyez une hiérarchie de classes avec un motif en diamant, méfiez-vous, ça pourrait bien être du multiple inheritance déguisé ! (Et en Java, c’est interdit, rappelez-vous.)