Maîtriser l'héritage Java : Sous-classes, Superclasses et Principes fondamentaux

L'héritage est le processus par lequel une classe acquiert les propriétés (méthodes et champs) d'une autre. Il organise l'information de manière hiérarchique.

• Sous-classe (classe dérivée, classe fille) : hérite des propriétés
• Superclasse (classe de base, classe mère) : fournit les propriétés

Mot-clé extends

class Super {
    // ...
}
class Sous extends Super {
    // ...
}

Exemple concret

class Calcul {
    int z;
    public void addition(int x, int y) {
        z = x + y;
        System.out.println("Somme : " + z);
    }
    public void soustraction(int x, int y) {
        z = x - y;
        System.out.println("Différence : " + z);
    }
}

public class MonCalcul extends Calcul {
    public void multiplication(int x, int y) {
        z = x * y;
        System.out.println("Produit : " + z);
    }
    
    public static void main(String args[]) {
        int a = 20, b = 10;
        MonCalcul demo = new MonCalcul();
        demo.addition(a, b);
        demo.soustraction(a, b);
        demo.multiplication(a, b);
    }
}

Résultat :

Somme : 30
Différence : 10
Produit : 200

Lorsqu'un objet MonCalcul est créé, une copie des membres de Calcul est incluse. L'objet sous-classe accède aux membres des deux classes.

Référence superclasse vs sous-classe

Calcul demo = new MonCalcul();
demo.addition(a, b);      // OK - méthode de Calcul
demo.soustraction(a, b);  // OK - méthode de Calcul
// demo.multiplication(a, b);  // ERREUR - méthode de MonCalcul inaccessible

Une référence de type superclasse ne voit que les membres de la superclasse. Pour accéder à tout, utilisez une référence de type sous-classe.

Note : Les constructeurs ne sont pas hérités, mais le constructeur de la superclasse peut être invoqué depuis la sous-classe.

Le mot-clé super

Similaire à this, utilisé pour :

• Différencier les membres de la superclasse de ceux de la sous-classe (mêmes noms)
• Invoquer le constructeur de la superclasse

Différencier les membres

super.variable
super.methode();

Exemple complet

class SuperClasse {
    int num = 20;
    public void afficher() {
        System.out.println("Affichage superclasse");
    }
}

public class SousClasse extends SuperClasse {
    int num = 10;
    public void afficher() {
        System.out.println("Affichage sous-classe");
    }
    
    public void maMethode() {
        SousClasse sous = new SousClasse();
        sous.afficher();        // méthode sous-classe
        super.afficher();       // méthode superclasse
        System.out.println("num sous-classe : " + sous.num);
        System.out.println("num superclasse : " + super.num);
    }
    
    public static void main(String args[]) {
        new SousClasse().maMethode();
    }
}

Résultat :

Affichage sous-classe
Affichage superclasse
num sous-classe : 10
num superclasse : 20

Invoquer le constructeur de la superclasse

super(valeurs);

Exemple : constructeur paramétré

class SuperClasse {
    int age;
    SuperClasse(int age) { this.age = age; }
    public void getAge() {
        System.out.println("Age dans superclasse : " + age);
    }
}

public class SousClasse extends SuperClasse {
    SousClasse(int age) { super(age); }
    
    public static void main(String args[]) {
        SousClasse s = new SousClasse(24);
        s.getAge();
    }
}

Résultat : Age dans superclasse : 24

Relation IS-A

"Cet objet est un type de cet autre objet". Le mot-clé extends réalise l'héritage.

public class Animal { }
public class Mammifere extends Animal { }
public class Reptile extends Animal { }
public class Chien extends Mammifere { }

Vérités :

• Animal est superclasse de Mammifere et Reptile
• Mammifere et Reptile sont sous-classes d'Animal
• Chien est sous-classe de Mammifere et Animal

Relations IS-A :

• Mammifere EST-UN Animal
• Reptile EST-UN Animal
• Chien EST-UN Mammifere
• Donc : Chien EST-UN Animal

L'opérateur instanceof vérifie cette relation :

Animal a = new Animal();
Mammifere m = new Mammifere();
Chien d = new Chien();
System.out.println(m instanceof Animal);  // true
System.out.println(d instanceof Mammifere); // true
System.out.println(d instanceof Animal);   // true

Mot-clé implements

Utilisé pour implémenter une interface (une classe ne peut pas étendre une interface).

public interface Animal { }
public class Mammifere implements Animal { }
public class Chien extends Mammifere { }

Relation HAS-A

Basée sur la composition : une classe possède une instance d'une autre. Réduit la duplication et les bugs.

public class Vehicule { }
public class Vitesse { }
public class Camionnette extends Vehicule {
    private Vitesse v;  // Camionnette A-UNE Vitesse
}

La classe Vitesse est réutilisable. Camionnette cache les détails d'implémentation (encapsulation).

Types d'héritage

• Simple : une sous-classe étend une superclasse
• Multiniveau : A → B → C
• Hiérarchique : une superclasse, plusieurs sous-classes

Important : Java ne supporte pas l'héritage multiple de classes :

// ILLÉGAL
public class Test extends Animal, Mammifere { }

Mais une classe peut implémenter plusieurs interfaces, ce qui contourne cette limitation.