Redéfinition et surcharge Java

Redéfinition

La redéfinition signifie qu'une sous-classe définit une méthode avec le même nom, la même liste de paramètres et le même type de retour qu'une méthode de sa classe parente, et que l'implémentation de la méthode de la sous-classe remplace l'implémentation de la méthode de la classe parente.C'est-à-dire que l'enveloppe reste inchangée, mais le cœur est réécrit !

L'avantage de la redéfinition est qu'une sous-classe peut définir le comportement qui lui est propre selon ses besoins. Autrement dit, la sous-classe peut implémenter la méthode de la classe parente selon ses besoins. Ainsi, lorsqu'un objet de la sous-classe est utilisé pour appeler la méthode, c'est la méthode de la sous-classe qui est exécutée plutôt que celle de la classe parente.

Une méthode qui redéfinit ne peut pas lancer de nouvelles exceptions vérifiées ni des exceptions plus larges que celles déclarées par la méthode redéfinie. Par exemple : une méthode de la classe parente déclare une exception vérifiée IOException, mais lorsque vous redéfinissez cette méthode, vous ne pouvez pas lancer Exception, car Exception est la classe parente de IOException. Vous pouvez lancer IOException ou une exception qui est une sous-classe de IOException.

Dans les principes orientés objet, la redéfinition signifie que toute méthode existante peut être redéfinie. Voici un exemple :

Code du fichier TestDog.java :

class Animal{ public void move(){ System.out.println("Les animaux peuvent se déplacer"); } } class Dog extends Animal{ public void move(){ System.out.println("Les chiens peuvent courir et marcher"); } } public class TestDog{ public static void main(String args[]){ Animal a = new Animal(); //objet Animal Animal b = new Dog(); //objet Dog a.move();//Exécuter la méthode de la classe Animal b.move();//Exécuter la méthode de la classe Dog } }

Le résultat de la compilation et de l'exécution de l'exemple ci-dessus est le suivant :

Animals can move
Dogs can run and walk

Dans l'exemple ci-dessus, on peut voir que bien que b soit de type Animal, il exécute la méthode move de la classe Dog.

Cela est dû au fait que, pendant la phase de compilation, seul le type de référence du paramètre est vérifié.

Cependant, à l'exécution, la machine virtuelle Java (JVM) détermine le type de l'objet et exécute la méthode de l'objet.

Par conséquent, dans l'exemple ci-dessus, la compilation réussit parce que la classe Animal possède la méthode move ; cependant, à l'exécution, la méthode de l'objet spécifique est exécutée.

Considérez l'exemple suivant :

Code du fichier TestDog.java :

class Animal{ public void move(){ System.out.println("Les animaux peuvent se déplacer"); } } class Dog extends Animal{ public void move(){ System.out.println("Les chiens peuvent courir et marcher"); } public void bark(){ System.out.println("Les chiens peuvent aboyer"); } } public class TestDog{ public static void main(String args[]){ Animal a = new Animal(); //objet Animal Animal b = new Dog(); //objet Dog a.move();//Exécuter la méthode de la classe Animal b.move();//Exécuter la méthode de la classe Dog b.bark(); } }

Le résultat de la compilation et de l'exécution de l'exemple ci-dessus est le suivant :

TestDog.java:30: cannot find symbol
symbol  : method bark()
location: class Animal
                b.bark();
                 ^

Le programme générera une erreur de compilation car le type de référence de b, Animal, ne possède pas de méthode bark.

Règles de redéfinition des méthodes

  • La liste des paramètres doit être exactement la même que la liste des paramètres de la méthode redéfinie.

  • Le type de retour peut être différent du type de retour de la méthode redéfinie, mais il doit être une classe dérivée de la valeur de retour de la classe parente (le type de retour doit être identique dans Java 5 et les versions antérieures, et peut être différent dans Java 7 et les versions ultérieures).

  • Le niveau d'accès ne peut pas être inférieur au niveau d'accès de la méthode redéfinie dans la classe parente. Par exemple : si une méthode de la classe parente est déclarée comme public, alors la redéfinition de cette méthode dans la sous-classe ne peut pas la déclarer comme protected.

  • Les méthodes membres d'une classe parente ne peuvent être redéfinies que par ses sous-classes.

  • Les méthodes déclarées comme final ne peuvent pas être redéfinies.

  • Les méthodes déclarées comme static ne peuvent pas être redéfinies, mais elles peuvent être redéclarées.

  • Si la sous-classe et la classe parente se trouvent dans le même paquetage, la sous-classe peut redéfinir toutes les méthodes de la classe parente, à l'exception des méthodes déclarées comme private et final.

  • Si la sous-classe et la classe parente ne se trouvent pas dans le même paquetage, la sous-classe peut uniquement redéfinir les méthodes non final de la classe parente déclarées comme public et protected.

  • Une méthode qui redéfinit peut lever n'importe quelle exception non vérifiée, que la méthode redéfinie lève ou non une exception. Cependant, une méthode qui redéfinit ne peut pas lever de nouvelles exceptions vérifiées, ni des exceptions vérifiées plus larges que celles déclarées par la méthode redéfinie, alors que l'inverse est autorisé.

  • Les constructeurs ne peuvent pas être redéfinis.

  • Si une classe ne peut pas être héritée, ses méthodes ne peuvent pas être redéfinies.

Utilisation du mot-clé super

Lorsque vous devez appeler la méthode redéfinie de la classe parente dans une sous-classe, vous devez utiliser le mot-clé super.

Code du fichier TestDog.java :

class Animal{ public void move(){ System.out.println("Les animaux peuvent se déplacer"); } } class Dog extends Animal{ public void move(){ super.move(); //Appel de la méthode de la classe parente à l'aide de super System.out.println("Les chiens peuvent courir et marcher"); } } public class TestDog{ public static void main(String args[]){ Animal b = new Dog(); //objet Dog b.move(); //Exécuter la méthode de la classe Dog } }

Le résultat de la compilation et de l'exécution de l'exemple ci-dessus est le suivant :

Animals can move
Dogs can run and walk

Surcharge

La surcharge signifie que, au sein d'une classe, des méthodes ont le même nom mais des paramètres différents. Le type de retour peut être identique ou différent.

Chaque méthode surchargée (ou constructeur) doit avoir une liste de types de paramètres unique.

L'utilisation la plus courante est la surcharge de constructeur.

Règles de surcharge :

  • Les méthodes surchargées doivent modifier la liste des paramètres (le nombre ou les types de paramètres doivent être différents) ;
  • Les méthodes surchargées peuvent modifier le type de retour ;
  • Les méthodes surchargées peuvent modifier le modificateur d'accès ;
  • Les méthodes surchargées peuvent déclarer de nouvelles exceptions vérifiées ou des exceptions vérifiées plus larges ;
  • Les méthodes peuvent être surchargées dans la même classe ou dans une sous-classe.
  • Le type de retour ne peut pas être utilisé comme critère pour distinguer les fonctions surchargées.

Exemple

Code du fichier Overloading.java :

public class Overloading { public int test(){ System.out.println("test1"); return 1; } public void test(int a){ System.out.println("test2"); } //Les deux suivants ont un ordre des types de paramètres différent public String test(int a,String s){ System.out.println("test3"); return "returntest3"; } public String test(String s,int a){ System.out.println("test4"); return "returntest4"; } public static void main(String[] args){ Overloading o = new Overloading(); System.out.println(o.test()); o.test(1); System.out.println(o.test(1,"test3")); System.out.println(o.test("test4",1)); } }

Différences entre la redéfinition et la surcharge

Point de différence Méthode surchargée Méthode redéfinie
Liste de paramètres Doit modifier Ne doit pas modifier
Type de retour Peut modifier Ne doit pas modifier
Exception Peut modifier Peut réduire ou supprimer, ne doit pas lever de nouvelles exceptions ni d'exceptions plus larges
Access Peut modifier Ne doit pas imposer de restrictions plus strictes (peut assouplir les restrictions)

Résumé

La redéfinition et la surcharge de méthode sont différentes manifestations du polymorphisme Java. La redéfinition est une manifestation du polymorphisme entre la classe parente et la sous-classe, et la surcharge peut être comprise comme une forme spécifique de polymorphisme.

  • (1) La surcharge de méthode se produit lorsqu'une classe définit plusieurs méthodes portant le même nom, mais dont les paramètres diffèrent en nombre, ou ont le même nombre mais des types et un ordre différents ; c'est ce qu'on appelle la surcharge de méthode.
  • (2) La redéfinition de méthode se produit lorsqu'une méthode existe dans une sous-classe avec le même nom qu'une méthode de la classe parente, et que le nombre et les types des paramètres sont identiques, ainsi que la valeur de retour ; c'est ce qu'on appelle la redéfinition.
  • (3) La surcharge de méthode est une manifestation du polymorphisme au sein d'une classe, tandis que la redéfinition de méthode est une manifestation du polymorphisme entre la sous-classe et la classe parente.

Autres extensions