@Override en Java

1. Différence entre le remplacement et la surcharge en Java
2. L’annotation @Override en Java

Dans ce guide, nous approfondirons le sujet de la substitution et de l’annotation @override en Java. La substitution est le concept où une classe enfant a la même méthode que dans sa classe parent. Ce concept est un exemple de polymorphisme d’exécution.

Différence entre le remplacement et la surcharge en Java

Le dépassement est souvent confondu avec un autre terme similaire appelé surcharge. Avant d’aller plus loin, voyons les différences significatives entre eux dans le tableau suivant.

L’annotation @Override en Java

L’annotation @Override indique au compilateur Java que nous voulons surcharger une méthode de la superclasse. Bien qu’il ne soit pas nécessaire d’utiliser @Override chaque fois que nous voulons l’implémenter dans un processus, nous vous recommandons de l’utiliser car nous pouvons faire des erreurs lors de la création des méthodes. Par exemple, nous pouvons fournir différents paramètres dans la classe enfant, ce qui la surcharge au lieu de la redéfinir.

Pour surmonter l’erreur, nous utilisons @Override au-dessus du nom de la méthode dans les classes enfants qui indique au compilateur que nous voulons surcharger la méthode. Si nous commettons une erreur, le compilateur renverra une erreur.

Dans l’exemple ci-dessous, nous avons quatre classes. La classe OverrideJava est l’endroit où se trouve la méthode main() et où les méthodes des autres classes seront appelées en utilisant leurs objets. Ensuite, nous avons trois autres classes dans lesquelles la FirstClass a une méthode appelée method1() avec un message d’impression à l’intérieur. Enfin, la classe SecondClass étend la FirstClass qui utilise le concept d’héritage. Ici, nous utilisons le même nom de méthode et la même signature method1() que sa classe parente comme FirstClass.

Notez que dans la classe SecondClass, nous utilisons l’annotation @Override. Ensuite, nous étendons la SecondClass dans la classe ThirdClass et utilisons la méthode method1() avec l’annotation. Pour vérifier quelle méthode est appelée, nous créons un objet de ThirdClass, qui est la classe enfant, et appelons method1(). Dans la sortie, nous observons que la méthode à l’intérieur de ThirdClass est appelée parce que l’enfant a modifié l’implémentation interne après le parent.

public class OverrideJava {
  public static void main(String[] args) {
    ThirdClass thirdClass = new ThirdClass();
    thirdClass.method1();
  }
}

class ThirdClass extends SecondClass {
  @Override
  void method1() {
    System.out.println("Overriding method1 in Third Class");
  }
}

class SecondClass extends FirstClass {
  @Override
  void method1() {
    System.out.println("Overriding method1 in Second Class");
  }
}

class FirstClass {
  void method1() {
    System.out.println("This is method1");
  }
}

Production:

Overriding method1 in Third Class

Si nous voulons appeler la method1() de la classe parent au lieu de la classe enfant, nous pouvons utiliser super.method1() qui appelle la method1() de sa super classe. La sortie montre qu’à l’intérieur de ThirdClass d’abord, sa classe parent qui est la méthode SecondClass est appelée, puis sa propre implémentation est appelée.

public class OverrideJava {
  public static void main(String[] args) {
    ThirdClass thirdClass = new ThirdClass();
    thirdClass.method1();
  }
}

class ThirdClass extends SecondClass {
  @Override
  void method1() {
    super.method1();
    System.out.println("Overriding method1 in Third Class");
  }
}

class SecondClass extends FirstClass {
  @Override
  void method1() {
    System.out.println("Overriding method1 in Second Class");
  }
}

class FirstClass {
  void method1() {
    System.out.println("This is method1");
  }
}

Production:

Overriding method1 in Second Class
Overriding method1 in Third Class