Dans le chapitre précédent, nous avons parlé de super classes et de sous-classes. Si une classe hérite d'une méthode de sa super classe, il est possible de redéfinir la méthode à condition qu'elle ne soit pas définie comme étant final.

Le bénéfice de la substitution est: la capacité de définir un comportement spécifique au type de sous-classe, ce qui signifie qu'une sous-classe peut implémenter une méthode de classe parent basée sur ses besoins.

En termes axés sur l'objet, des moyens primordiaux pour redéfinir la fonctionnalité d'une méthode existante.

Exemple:

Examinons un exemple.

class Animal{
   public void move(){
      System.out.println("Animals can move");
   }
}

class Dog extends Animal{
   public void move(){
      System.out.println("Dogs can walk and run");
   }
}

public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal reference and object
      Animal b = new Dog(); // Animal reference but Dog object
      a.move();// runs the method in Animal class
      b.move();//Runs the method in Dog class
   }
}

Cela produirait le résultat suivant:

Animals can move

Dogs can walk and run

Dans l'exemple ci-dessus, vous pouvez voir que même si b est un type d'Animal, il exécute la méthode move() dans la classe Dog. La raison en est: en temps de compilation, la vérification est effectuée sur le type de référence. Cependant, dans le temps d'exécution, JVM détermine le type d'objet et exécute la méthode qui appartient à cet objet particulier.

Par conséquent, dans l'exemple ci-dessus, le programme va se compiler correctement puisque la classe Animal a la méthode move(). Ensuite, au moment de l'exécution, il exécute la méthode spécifique pour cet objet.

Considérons l’exemple suivant :

class Animal{
   public void move(){
      System.out.println("Animals can move");
   }
}

class Dog extends Animal{
   public void move(){
      System.out.println("Dogs can walk and run");
   }
   public void bark(){
      System.out.println("Dogs can bark");
   }
}

public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal reference and object
      Animal b = new Dog(); // Animal reference but Dog object
      a.move();// runs the method in Animal class
      b.move();//Runs the method in Dog class
      b.bark();
   }
}

 TestDog.java:30: cannot find symbol

symbol : method bark()

location: class Animal

                b.bark();

                 ^

 Ce programme lancera une erreur de temps de compilation puisque le type de référence de b Animal n'a pas de méthode bark().

Règles pour la substitution de méthode

• La liste des arguments devrait être exactement la même que celle de la méthode redéfinie.
• Le type de retour devrait être le même ou un sous-type du type de retour déclaré dans la méthode d'origine surchargée dans la superclasse.
• Le niveau d'accès ne peut pas être plus restrictif que le niveau d'accès de la méthode surchargée. Par exemple: si la méthode de superclasse est déclarée comme publique, la méthode redéfinie dans la sous-classe ne peut être ni privée ni protégée.
• Les méthodes d'instance ne peuvent être redéfinies que si elles sont héritées par la sous-classe.
• Une méthode déclarée avec le mot clé final ne peut pas être redéfinie.
• Une méthode déclarée avec le mot clé static ne peut pas être redéfinie mais peut être déclarée à nouveau.
• Si une méthode ne peut pas être héritée, elle ne peut pas être redéfinie.
• Une sous-classe dans le même paquetage que la superclasse de l'instance peut redéfinir toute méthode de superclasse qui n'est pas déclarée privée ou final.
• Une sous-classe dans un paquetage différent ne peut que redéfinir les méthodes non définies déclarées publiques ou protégées.
• Une méthode de substitution peut attraper toutes les exceptions de suppression, indépendamment du fait que la méthode redéfinie lance des exceptions ou non. Cependant, la méthode primordiale ne devrait pas lancée des exceptions vérifiées qui sont nouvelles ou plus larges que celles déclarées par la méthode redéfinie. La méthode primordiale peut lancer plus ou moins d'exceptions que la méthode redéfinie.
• Les constructeurs ne peuvent pas être redéfinis.

Utilisation du mot clé super

En invoquant une version de superclasse d'une méthode surchargée, le mot clé super  est utilisé.

class Animal{
   public void move(){
      System.out.println("Animals can move");
   }
}

class Dog extends Animal{
   public void move(){
      super.move(); // invokes the super class method
      System.out.println("Dogs can walk and run");
   }
}

public class TestDog{
   public static void main(String args[]){
      Animal b = new Dog(); // Animal reference but Dog object
      b.move(); //Runs the method in Dog class
   }
}

 Cela produirait le résultat suivant:

Animals can move

Dogs can walk and run

• ← Héritage
• Sommaire du cours
• Le Polymorphisme →