Héritage

L'héritage est un mécanisme des langages à objets particulièrement utile en génie logiciel, car il offre des possibilités de réutilisation par enrichissement de classes déjà écrites. Il permet de définir une classe à partir d'une autre, en héritant des membres de cette dernière.

En voici un exemple. Nous devons définir une classe PointColore, dont les instances sont des points colorés^1.4. Une première solution consisterait à définir deux champs, un point et une couleur, en utilisant la classe Point déjà définie et la classe java.awt.Color (du paquet java.awt) :  

class PointColore {
 Point point;
 java.awt.Color couleur;

 PointColore(double x, double y, java.awt.Color couleur) {
   point = new Point(x, y);
   this.couleur = couleur;
 }
 void translater(double dx, double dy) {
   point.translater(dx, dy);
 }
}

Cette classe utilise la classe Point, un de ses constructeurs et une de ses méthodes. On peut l'utiliser ainsi :

class Test {
 public static void main(String[] args) {
   PointColore pointRouge = 
     new PointColore(1, 2, java.awt.Color.red);
   pointRouge.translater(1, 1);
 }
}

Ce mode de définition d'une classe est dit par composition : un PointColore se compose d'un Point et d'une java.awt.Color. En outre, un PointColore délègue la translation à son composant point. Ces deux techniques, de composition et de délégation, sont très utilisées. Par exemple, on définira une interface graphique à partir de plusieurs composants graphiques (des boutons, barres de menus, menus, etc.) et on déléguera à des observateurs le soin de traiter certains événements (presser un bouton, choisir un item dans un menu, etc.).

                Java propose une autre technique, dite d'extension, qui permet de réutiliser une (seule) classe et ses méthodes : il suffit de déclarer la classe PointColore comme une extension de Point, à l'aide de la clause extends, et de lui ajouter un champ de type java.awt.Color. La classe Point est dite parente ou sur-classe directe de PointColore, celle-ci étant dérivée, ou sous-classe directe de Point.

class PointColore extends Point {
 java.awt.Color couleur;

 PointColore(double x, double y, java.awt.Color couleur) {
   super(x, y);
   this.couleur = couleur;
 }
 PointColore() {
   super();
   this.couleur = java.awt.Color.black;
 }
}

Ses constructeurs commencent par invoquer le constructeur de la classe parente, par l'opérateur super  . En effet, le nom super peut être employé avec une liste d'arguments pour invoquer explicitement un constructeur de la classe parente, celui qui accepte les mêmes types d'arguments que cette invocation de super. Une invocation de super( ... ) ne peut figurer qu'en première instruction du corps du constructeur (retenir qu'avant de créer un objet, il faut d'abord créer son << parent >>). Une invocation de super() n'est pas obligatoire, mais si elle n'est pas explicite, une invocation implicite   de super() a toujours lieu, sans argument, ce qui suppose que la classe parente a un constructeur sans paramètre.

Tous les membres de la classe Point, c'est-à-dire ses deux champs x et y et sa méthode translater, sont alors hérités par PointColore (figure 1.9) :

  PointColore pc = new PointColore(1, 2, java.awt.Color.red);
  pc.translater(2, 2);

 

De façon générale, ce mécanisme d'extension spécifié par la clause extends a deux effets :

• la classe dérivée hérite de certains membres de sa classe parente ;
• la classe dérivée est un sous-type de sa classe parente.

L'héritage n'est pas systématique. Il y a d'abord une condition d'accessibilité, que nous préciserons par la suite. Par exemple, les membres privés ne sont pas hérités. Les méthodes d'instance ne sont héritées que si elles ne sont pas redéfinies dans la classe dérivée. Enfin, les constructeurs ne sont jamais hérités.

  À l'exception de la classe Object, toute classe dérive d'une autre classe ; si la mention de l'extension est absente, ceci signifie que la classe dérive d'Object. Ceci permettra de réaliser une forme de généricité qui permet de traiter tous les objets de façon uniforme.