Section courante

A propos

Section administrative du site

Héritage

L'héritage est l'un des quatre piliers fondamentaux de la programmation orientée objet, avec l'encapsulation, l'abstraction et le polymorphisme.

Il permet de créer une nouvelle classe à partir d'une classe existante, en réutilisant ses attributs et ses méthodes, tout en pouvant les spécialiser, étendre ou modifier.

La classe existante est appelée classe mère, classe parente ou superclasse, tandis que la nouvelle classe est appelée classe fille, classe dérivée ou sous-classe.

L'héritage modélise une relation de type « est-un » (is-a).

Objectifs et intérêts de l'héritage

L'héritage répond à plusieurs objectifs essentiels :

Réutilisation du code

Les comportements communs sont définis une seule fois dans la classe parente et partagés par toutes les classes filles.

Factorisation

Les propriétés et méthodes communes sont regroupées dans une classe générique, ce qui réduit les duplications.

Extensibilité

Il est possible d'ajouter de nouveaux comportements sans modifier la classe existante.

Modélisation du réel

L'héritage permet de représenter des hiérarchies naturelles (Animal &rar; Mammifère → Chien).

Vocabulaire fondamental

Terme Définition
Superclasse Classe dont on hérite
Sous-classe Classe qui hérite
Hériter Récupérer attributs et méthodes
Redéfinition Modifier le comportement hérité
Extension Ajouter de nouveaux membres
super Accès à la classe parente

Relation « est-un » (IS-A)

Avant d'utiliser l'héritage, il faut se poser la question :

  La classe fille est-elle réellement un type de la classe mère ?

Exemples valides :

Exemples invalides :

Si la relation IS-A n'est pas claire, l'héritage est probablement un mauvais choix.

Structure de base de l'héritage

Classe parente

Voici un exemple en Java :

  1. class Animal {
  2.     protected String nom;
  3.  
  4.     public void manger() {
  5.         System.out.println("L'animal mange");
  6.     }
  7. }

Classe fille

Voici un exemple en Java :

  1. class Chien extends Animal {
  2.  
  3.     public void aboyer() {
  4.         System.out.println("Le chien aboie");
  5.     }
  6. }

Utilisation

Voici un exemple en Java :

  1. Chien chien = new Chien();
  2. chien.manger();  // méthode héritée
  3. chien.aboyer();  // méthode spécifique

Héritage et visibilité

Les règles de visibilité influencent directement l'héritage :

Visibilité Accessible dans la sous-classe
public Oui
protected Oui
private Non

Les attributs private ne sont pas directement accessibles dans la sous-classe, mais restent accessibles via des méthodes publiques ou protégées.

Redéfinition de méthodes (Override)

Principe

La redéfinition permet à une sous-classe de modifier le comportement d'une méthode héritée. Voici un exemple en Java :

  1. class Chien extends Animal {
  2.  
  3.     @Override
  4.     public void manger() {
  5.         System.out.println("Le chien mange des croquettes");
  6.     }
  7. }

Règles de redéfinition

Le mot-clef super

Appel d'un constructeur parent

Voici un exemple en Java :

  1. class Animal {
  2.     protected String nom;
  3.  
  4.     public Animal(String nom) {
  5.         this.nom = nom;
  6.     }
  7. }
  8.  
  9. class Chien extends Animal {
  10.     public Chien(String nom) {
  11.         super(nom);
  12.     }
  13. }

Appel d'une méthode parente

Voici un exemple en Java :

  1. @Override
  2. public void manger() {
  3.     super.manger();
  4.     System.out.println("... avec appétit !");
  5. }

Héritage et constructeurs

Héritage simple et multiple

Héritage simple

Un seul parent (Java, C#, PHP).

  1. class A {}
  2. class B extends A {}

Héritage multiple

Plusieurs parents (C++, Python).

  1. class C(A, B):
  2.     pass

Java contourne ce problème via les interfaces.

Problèmes liés à l'héritage

Couplage fort

La sous-classe dépend fortement de la superclasse.

Effet domino

Un changement dans la classe mère peut impacter toutes les classes filles.

Hiérarchies trop profondes

Rend le code difficile à comprendre et à maintenir.

Héritage vs composition

Principe clef : « Préférer la composition à l'héritage »

Héritage Composition
Relation IS-A Relation HAS-A
Couplage fort Couplage faible
Rigide Flexible
Hiérarchie Assemblage

Exemple de composition en Java :

  1. class Voiture {
  2.     private Moteur moteur;
  3. }

Bonnes pratiques d'héritage

Héritage et conception orientée objet

L'héritage est un outil puissant mais dangereux s'il est mal utilisé. Bien maîtrisé, il permet une modélisation élégante et une forte réutilisation du code. Mal utilisé, il engendre rigidité, complexité et fragilité.

Conclusion

L'héritage permet de partager et spécialiser des comportements, mais il doit être utilisé avec discernement. Une bonne conception orientée objet repose sur un équilibre entre héritage, composition et interfaces.



Dernière mise à jour : Jeudi, le 1er janvier 2026