Maîtriser l'héritage Java : concepts, types et exemples pratiques

Maîtriser l'héritage Java

Explorez l'héritage Java en profondeur – comprenez ses principes, exemples concrets, et comment l'appliquer pour un code plus propre et réutilisable.

L'héritage est une pierre angulaire de la programmation orientée objet qui permet de créer une nouvelle classe basée sur une existante.

La classe dérivée est appelée sous-classe (enfant ou dérivée), tandis que la classe qu'elle étend est la superclasse (parent ou base). Le mot-clé extends établit cette relation.

class Animal { // méthodes et champs } class Dog extends Animal { // Dog hérite champs et méthodes de Animal }

Ici, Dog hérite de tous les membres de Animal – la sous-classe gagne la fonctionnalité du parent.

---

Exemple 1 : Héritage de base

class Animal { String name; public void eat() { System.out.println("I can eat"); } } class Dog extends Animal { public void display() { System.out.println("My name is " + name); } } class Main { public static void main(String[] args) { Dog labrador = new Dog(); labrador.name = "Rohu"; labrador.display(); labrador.eat(); } }

Sortie

My name is Rohu I can eat

Dans cet exemple, Dog hérite name et eat() de Animal, donc un objet Dog peut y accéder directement.

---

La relation is‑a

L'héritage en Java représente une relation is‑a : une sous-classe est une forme spécialisée de sa superclasse.

• Car is a Vehicle
• Orange is a Fruit
• Surgeon is a Doctor
• Dog is an Animal

Ces hiérarchies naturelles justifient l'utilisation de l'héritage.

---

Redéfinition de méthode

Quand une sous-classe définit une méthode avec la même signature que sa superclasse, la méthode de la sous-classe redéfinit la version de la superclasse. Cela permet le polymorphisme d'exécution.

Exemple 2 : Redéfinition de eat()

class Animal { public void eat() { System.out.println("I can eat"); } } class Dog extends Animal { @Override public void eat() { System.out.println("I eat dog food"); } public void bark() { System.out.println("I can bark"); } } class Main { public static void main(String[] args) { Dog labrador = new Dog(); labrador.eat(); labrador.bark(); } }

Sortie

I eat dog food I can bark

L'appel eat() sur labrador se résout vers la méthode redéfinie dans Dog.

Astuce : L'annotation @Override est optionnelle mais fortement recommandée – elle assure que le compilateur vérifie que vous redéfinissez bien une méthode.

---

Utiliser super pour accéder à la superclasse

Lors de la redéfinition, le mot-clé super permet d'invoquer l'implémentation du parent.

Exemple 3 : super dans eat()

class Animal { public void eat() { System.out.println("I can eat"); } } class Dog extends Animal { @Override public void eat() { super.eat(); System.out.println("I eat dog food"); } public void bark() { System.out.println("I can bark"); } } class Main { public static void main(String[] args) { Dog labrador = new Dog(); labrador.eat(); labrador.bark(); } }

Sortie

I can eat I eat dog food I can bark

Ici, super.eat() appelle la méthode définie dans Animal avant d'exécuter la logique de la sous-classe.

De même, super peut invoquer les constructeurs de la superclasse.

---

Membres protégés dans l'héritage

Les champs ou méthodes marqués protected sont accessibles aux sous-classes indépendamment du package.

Exemple 4 : Accès aux membres protégés

class Animal { protected String name; protected void display() { System.out.println("I am an animal."); } } class Dog extends Animal { public void getInfo() { System.out.println("My name is " + name); } } class Main { public static void main(String[] args) { Dog labrador = new Dog(); labrador.name = "Rocky"; labrador.display(); labrador.getInfo(); } }

Sortie

I am an animal. My name is Rocky

La sous-classe peut librement lire et modifier le champ protégé name et appeler display().

---

Pourquoi utiliser l'héritage ?

• Réutilisation de code : Une classe enfant hérite automatiquement de tous les membres publics et protégés de son parent.
• Polymorphisme : La redéfinition permet l'envoi dynamique de méthodes, une fonctionnalité clé du polymorphisme d'exécution.

---

Types d'héritage

Java supporte cinq modèles conceptuels d'héritage – chacun utile dans différents scénarios.

1. Héritage simple

Une classe étend une seule superclasse.

---

2. Héritage multiniveau

Une sous-classe devient la superclasse d'une autre classe, créant une chaîne.

---

3. Héritage hiérarchique

Plusieurs sous-classes héritent d'une seule superclasse.

---

4. Héritage multiple

Java n'autorise pas une classe à étendre plus d'une classe, mais les interfaces offrent un moyen d'atteindre ce motif.

Note : L'héritage multiple peut être implémenté via les interfaces ; voir Java implements multiple inheritance.

---

5. Héritage hybride

Un mélange de deux ou plusieurs types d'héritage – par exemple, combiner l'héritage hiérarchique et multiple.