L'héritage et ses implications en Java: Une introduction

Beaucoup de gens confondent à tord et à travers le concept d'héritage en général et plus particulièrement en Java. Dans ce post, nous allons survoler le concept pour compréhention tout en utilisant des exemples pratiques.

L'héritage kesako?

Pour faire simple, je vais paraphraser un auteur célèbre:

L'héritage consiste à créer une nouvelle classe à partir d'une
classe existante et en lui ajoutant de nouvelles fonctionalités.

En clair, l'héritage est une réutilisation du code ou de fonctionalité. Pour réutiliser une fonctionalité, il faudrait que les concepts à implémenter soient proches ou aient un point de raliement. Dans ce cas il faudrait que le principe de:

... sont tous des ... (principe du ... est un ...)

soit respecté. Par exemple: Le chien et le chat sont tous des animaux; L'avion et le bateau sont tous des engins mobiles; etc.

Vue graphique

En modélisation UML, on aura un résultat graphique comme celui qui suit.

Ce qui est sur cette image signifie simplement que le chien et le chat sont tous deux des animaux. Ou bien autrement dit, le chien et le chat renvoient tous à des animaux!
Le chien possède les caractéristiques des animaux (ici recevoir un nom) et en plus de cela, il peut aboyer().

Implémentation

Une implémentation Java simple de ces trois (3) entités pourrait ressembler à ceci:

// src/Animal.java
class Animal {
    protected String nom;

    // Constructeur
    public Animal() {
       this.nom = "";
    }

    public void recevoirNom(String nom) {
       this.nom = nom;
    }
}

// src/Chat.java
class Chat extends Animal {
    // Constructeur
    public Chat() {
       super();
    }

    public void miauler() {
       System.out.println("miaou!");
    }
}

// src/Chien.java
class Chien extends Animal {
    // Constructeur
    public Chien() {
       super();
    }

    public void aboyer() {
       System.out.println("wouf!");
    }
}

Exemples de mise en oeuvre

Face à l'implémentation ci-dessus, voici des choses possibles et des choses impossibles:

Animal animal = new Animal();
animal.recevoirNom("choui"); // Correct: Animal a recevoirNom()
animal.aboyer();            // Erroné: Tous les animaux ne sont pas des chiens. 
animal.miauler();          // Erroné: Tous les aminaux ne sont pas des chats.

Chien  chien = new Chien();
chien.recevoirNom("choui"); // Correct: Tous les chiens sont des animaux
chien.aboyer();            // Correct: Tous les chiens peuvent aboyer. 
chien.miauler();          // Erroné: Les chiens sont des animaux mais ils ne sont pas des chats.

Au vu des exemples précédents, vous pouvez établir vous-même des vérités et des contres vérités sur les animaux, les chiens et le chats mais il y a un pétit bémol.

Il est clair que tous les chiens et chats sont des animaux. Cela veut dire que l'on peut passer un chien ou un chat en place et lieu d'un animal. Donc ces expressions sont tout à fait possibles:

Animal  animal = new Chien(); // Un chien est un animal donc là où on veut un animal, on peut passer un chien: no problemo!
Animal animal2 = new Chat(); // no problemo!

L'exemple précédent est bon mais il peut vous poser le piège du type de donnée. L'exemple qui suit le démontre avec des commentaires:

Animal  milou = new Chien(); 
milou.recevoirNom("milou"); // Correct: le type de milou est Animal et recevoirNom() est bien accessible dedans là-bas!
milou.aboyer();             // Erroné: le type de milou est Animal et aboyer() n'est pas disponible dans Animal bien que milou est une reference de chien

Chat miola = new Animal(); // Erroné: Les Animaux ne sont pas que des chats donc là où on veut un chat, on ne peut pas passer n'importe quel aninal!

Conclusion

Merci cher lecteur pour le temps passé à lire cet article. Vos remarques et suggestions sont les bienvenues. Commentez si vous voulez d'autres articles comme celui-ci.

Vous pouvez mes tutoriels de developement web sur mon blog.