Introduction

Lorsqu'on définit une sous-classe SC d'une classe C, il est possible de donner une nouvelle définition soit de ses variables d'instance ou de classe soit de ses méthodes de classe ou d'instance (sauf si elles ont l'attribut final), cette dernière possibilité contribuant au polymorphisme.

Ce qu'on nomme redéfinition («overriding»), et qu'il faut distinguer de la surcharge («overloading») dans le cas d'une méthode c'est la redéfinition du corps d'une méthode pour un profil donné. Pour un profil donné la redéfinition doit définir une fonction dont la valeur de retour est compatible avec celui qu'il possède dans la classe mère et sa visibilité doit être au moins égale à ce qu'elle était avant redéfinition.

La question que soulèvent ces possibilités, est de savoir d'une part ce qui est vu au travers des accès aux variables et d'autre part quelles méthodes sont invoquées effectivement à l'exécution. Il s'agit là incontestablement d'un des points clés de la programmation objets et de la programmation JAVA en particulier.

Il ne faut tout d'abord pas perdre de vue qu'avec Java, on est dans une stratégie de typage statique: dès la compilation un certain nombre de décisions vont être prises, le compilateur pouvant d'ailleurs refuser de générer un code exécutable si une incohérence en matière de typage ou une ambiguïté sont détectées.

Nous allons présenter ici les principes de base relatifs à ces mécanismes, les aspects plus compliqués étant traités ponctuellement dans différentes autres sections.

Les variables de classe

Une variable de classe ou d'instance d'une classe peut être redéfinie dans une sous-classe soit sous forme d'une variable de classe, soit sous forme d'une variable d'instance. Il n'y a aucune contrainte relativement au type associée à la variable dans la sous-classe. Dans tous les cas, la variable de la classe mère est masquée.


   --> cat Redef1.java

   class A{

      static int a = 10;

      static int b = 20;

      static int c = 30;

      static int d = 40;

      static String str = "Message d'accueil";

      }

   class B extends A{

      static int a = 40;

      static String str = "Welcome";

      static String c = "Bye";

      int b = 50;

      }

   public class Redef1 {

      public static void main(String[] arg){

      B b = new B();

      System.out.println(B.a);

      System.out.println(b.b);  // variable d'instance dans B    

      System.out.println(B.c);

      System.out.println(B.d);

      System.out.println(B.str);

      }

   }                                 

   --> java Redef1

   40       // val. de a dans B masquant celle dans A

   50       // val. de b dans B (var. d'instance masquant celle de classe de A)   

   Bye      // val. de c dans B (var. de classe masquant celle de B)

   40       // val. de d dans A (pas de masquage)

   Welcome  // val. de str dans B masquant celle dans A

Si on souhaite accéder à un champ masqué par une redéfinition il suffit de réaliser un transtypage de la référence dans le type de la sur-classe.
Ainsi, dans l'exemple précédent, l'accès aux champs masqués (c'est-à-dire les champs a, b, c et str est réalisable par


   --> cat Redef2.java
     .......
      System.out.println(((A)b).a);  
      System.out.println(((A)b).b);
      System.out.println(((A)b).c);       
      System.out.println(((A)b).str);
   }
   --> java Redef2
       .....
   10
   20
   30
   Message d'accueil

Introduction

Les variables de classe

Les méthodes de classe