Java - Remplacement

Dans le chapitre précédent, nous avons parlé des superclasses et des sous-classes. Si une classe hérite d'une méthode de sa superclasse, il y a une chance de remplacer la méthode à condition qu'elle ne soit pas marquée comme finale.

L'avantage de la substitution est: la possibilité 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 parente en fonction de ses exigences.

En termes orientés objet, remplacer signifie remplacer la fonctionnalité d'une méthode existante.

Exemple

Prenons 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 produira le résultat suivant -

Production

Animals can move
Dogs can walk and run

Dans l'exemple ci-dessus, vous pouvez voir que même si best un type d'Animal, il exécute la méthode move dans la classe Dog. La raison en est: Au moment de la compilation, le contrôle est effectué sur le type de référence. Cependant, lors de l'exécution, JVM détermine le type d'objet et exécutera la méthode qui appartient à cet objet particulier.

Par conséquent, dans l'exemple ci-dessus, le programme se compilera 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.

Prenons l'exemple suivant -

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 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();
   }
}

Cela produira le résultat suivant -

Production

TestDog.java:26: error: cannot find symbol
      b.bark();
       ^
  symbol:   method bark()
  location: variable b of type Animal
1 error

Ce programme lancera une erreur de compilation car le type de référence de b Animal n'a pas de méthode du nom de bark.

Règles de remplacement de méthode

La liste d'arguments doit être exactement la même que celle de la méthode remplacée.
Le type de retour doit être le même ou un sous-type du type de retour déclaré dans la méthode remplacée d'origine dans la superclasse.
Le niveau d'accès ne peut pas être plus restrictif que le niveau d'accès de la méthode remplacée. Par exemple: si la méthode de la superclasse est déclarée publique, la méthode de remplacement dans la sous-classe ne peut être ni privée ni protégée.
Les méthodes d'instance ne peuvent être remplacées que si elles sont héritées par la sous-classe.
Une méthode déclarée finale ne peut pas être remplacée.
Une méthode déclarée static ne peut pas être remplacée mais peut être re-déclarée.
Si une méthode ne peut pas être héritée, elle ne peut pas être remplacée.
Une sous-classe dans le même package que la superclasse de l'instance peut remplacer toute méthode de superclasse qui n'est pas déclarée privée ou finale.
Une sous-classe dans un package différent ne peut remplacer que les méthodes non finales déclarées publiques ou protégées.
Une méthode de substitution peut lever toutes les exceptions de décochement, que la méthode remplacée lève des exceptions ou non. Cependant, la méthode de substitution ne doit pas lever d'exceptions vérifiées qui sont nouvelles ou plus larges que celles déclarées par la méthode substituée. La méthode de substitution peut lever des exceptions plus restreintes ou moins nombreuses que la méthode remplacée.
Les constructeurs ne peuvent pas être remplacés.

Utilisation du super mot-clé

Lors de l'appel d'une version superclasse d'une méthode remplacée, le super le mot-clé est utilisé.

Exemple

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 produira le résultat suivant -

Production

Animals can move
Dogs can walk and run