Remplacement de méthode en Java

Salut! Vous utilisez déjà des méthodes Java et en savez beaucoup sur elles. Vous avez probablement été confronté à la situation où une classe a plusieurs méthodes avec le même nom mais des paramètres différents. Vous vous souviendrez que dans ces cas, nous avons utilisé la surcharge de méthode. Aujourd'hui, nous envisageons une autre situation. Imaginez que nous ayons une seule méthode partagée, mais qu'elle doive faire des choses différentes dans différentes classes. Comment met-on en œuvre ce comportement ? Pour comprendre, considérons une classe parent Animal , qui représente des animaux, et nous allons y créer une méthode speak :

public class Animal {

   public void speak() {

       System.out.println("Hello!");
   }
}

Bien que nous venons tout juste de commencer à écrire le programme, vous voyez probablement un problème potentiel : il y a beaucoup d'animaux dans le monde, et ils « parlent » tous différemment : les chats miaulent, les canards cancanent et les serpents sifflent. Notre objectif est simple : éviter de créer des tonnes de méthodes de parole. Au lieu de créer une méthode catSpeak() pour miauler, une méthode snakeSpeak() pour siffler, etc., nous voulons appeler la méthode speak()méthode et faire siffler le serpent, miauler le chat et aboyer le chien. Nous pouvons facilement y parvenir en utilisant le remplacement de méthode. Wikipédia donne l'explication suivante du terme 'overriding' : Le remplacement de méthode, dans la programmation orientée objet, est une fonctionnalité de langage qui permet à une sous-classe ou à une classe enfant de fournir une implémentation spécifique d'une méthode qui est déjà fournie par l'une de ses superclasses ou classes parentes C'est essentiellement correct. Le remplacement de méthode vous permet de prendre une méthode de la classe parent et d'écrire votre propre implémentation dans chaque classe enfant. La nouvelle implémentation "remplace" l'implémentation du parent dans la classe enfant. Voyons à quoi cela ressemble dans un exemple. Créez 4 classes qui héritent de notre classe Animal :

public class Bear extends Animal {
   @Override
   public void speak() {
       System.out.println("Growl!");
   }
}
public class Cat extends Animal {

   @Override
   public void speak() {
       System.out.println("Meow!");
   }
}

public class Dog extends Animal {

   @Override
   public void speak() {
       System.out.println("Woof!");
   }
}


public class Snake extends Animal {

   @Override
   public void speak() {
       System.out.println("Hiss!");
   }
}

"Voici une petite astuce pour le futur : pour remplacer les méthodes de la classe parente, accédez au code de la classe enfant dans IntelliJ IDE, cliquez sur Ctrl+O et choisissez "Remplacer les méthodes..." dans le menu. Habituez-vous à utiliser les raccourcis clavier dès le départ — cela vous aidera à écrire des programmes plus rapidement ! Pour spécifier le comportement dont nous avons besoin, nous avons fait quelques choses :

1. Dans chaque classe enfant, nous avons créé une méthode portant le même nom que la méthode de la classe parent.


2. Nous avons dit au compilateur que nommer la méthode de la même manière que dans la classe parent n'était pas un hasard : nous voulons remplacer son comportement. Pour communiquer cela au compilateur, nous définissons l'annotation @Override au-dessus de la méthode.
   Lorsqu'elle est placée au-dessus d'une méthode, l'annotation @Override informe le compilateur (ainsi que les programmeurs lisant votre code) : " Tout va bien. Ce n'est pas une erreur. Je n'oublie pas. Je suis conscient qu'une telle méthode existe déjà et je veux la remplacer'.


3. Nous avons écrit l'implémentation dont nous avons besoin pour chaque classe enfant. Lorsque la méthode speak() est appelée, un serpent doit siffler, un ours doit grogner, etc.

Voyons comment cela fonctionne dans un programme :

public class Main {

   public static void main(String[] args) {

       Animal animal1 = new Dog();
       Animal animal2 = new Cat();
       Animal animal3 = new Bear();
       Animal animal4 = new Snake();

       animal1.speak();
       animal2.speak();
       animal3.speak();
       animal4.speak();
   }
}

Sortie console :

Woof!
Meow!
Growl!
Hiss!

Excellent! Tout fonctionne comme il se doit ! Nous avons créé 4 variables de référence qui stockent les objets de la classe parent Animal et nous leur avons attribué des instances de 4 classes enfants différentes. En conséquence, chaque objet présente son propre comportement. Pour chaque classe enfant, la méthode speak() surchargée a remplacé la méthode 'native' speak() dans la classe Animal (qui affiche simplement 'Hello!'). Le remplacement a plusieurs limites :

1. La méthode remplacée doit avoir les mêmes paramètres que la méthode parent.

   Si la méthode speak de la classe parent a un paramètre String , la méthode remplacée dans la classe enfant doit également avoir un paramètre String . Sinon, le compilateur générera une erreur :

   
   public class Animal {
   
      public void speak(String s) {
   
          System.out.println("Hello! " + s);
      }
   }
   
   public class Cat extends Animal {
   
      @Override // Error!
      public void speak() {
          System.out.println("Meow!");
      }
   }
   




2. La méthode redéfinie doit avoir le même type de retour que la méthode parent.

   Sinon, nous aurons une erreur de compilation :

   
   public class Animal {
   
      public void speak() {
   
          System.out.println("Hello!");
      }
   }
   
   
   public class Cat extends Animal {
   
      @Override
      public String speak() {         // Error!
          System.out.println("Meow!");
          return "Meow!";
      }
   }
   




3. Le modificateur d'accès de la méthode remplacée doit également être le même que celui de la méthode "d'origine" :

   
   public class Animal {
   	
         public void speak() {
   	
               System.out.println("Hello!");
         }
   }
   
   public class Cat extends Animal {
   
          @Override
          private void speak() {      // Error!
              System.out.println("Meow!");
          }
   }
   

Le remplacement de méthode en Java est une façon d'implémenter le polymorphisme (le principe de la POO que nous avons décrit dans la dernière leçon). Cela signifie que son principal avantage est la même flexibilité dont nous avons parlé précédemment. Nous pouvons construire un système simple et logique de classes, chacune ayant un comportement spécifique (les chiens aboient, les chats miaulent), avec une interface commune — une seule méthode speak() pour toutes plutôt que des tas de méthodes, par exemple dogSpeak() , speakCat () , etc...