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 super-classe, il est alors possible de remplacer la méthode à condition qu'elle ne soit pas marquée comme finale.

L'avantage de la redéfinition 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 besoins.

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

Exemple

Prenons un exemple.

Démo en direct

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 −

Sortie

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 la suivante :au moment de la compilation, la vérification est effectuée sur le type de référence. Cependant, lors de l'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 se compilera correctement puisque la classe Animal a la méthode move. Ensuite, lors de l'exécution, il exécute la méthode spécifique à cet objet.

Prenons l'exemple suivant −

Exemple

Démo en direct

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 −

Sortie

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 puisque 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 redéfinie.

• Le type de retour doit être le même ou un sous-type du type de retour déclaré dans la méthode redéfinie 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 final ne peut pas être remplacée.

• Une méthode déclarée statique 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 n'importe quelle exception de désactivation, que la méthode surchargé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 de substitution. La méthode de remplacement peut générer des exceptions plus étroites ou moins nombreuses que la méthode de remplacement.

• Les constructeurs ne peuvent pas être remplacés.

Utiliser le super mot-clé

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

Exemple

Démo en direct

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 −

Sortie

Animals can move
Dogs can walk and run