Quelle est la différence entre surcharger une méthode et la remplacer en Java?
Quelle est la différence entre surcharger une méthode et la remplacer en Java?
Y a-t-il une différence dans la signature de la méthode, le spécificateur d'accès, le type de retour, etc.?
Pour surcharger une méthode avec une nouvelle méthode, la nouvelle méthode doit avoir une signature différente. C'est à dire. deux méthodes surchargées ont le même nom, mais des paramètres différents. Voici un exemple de deux méthodes surchargées:
boolean isOdd(int number) { ... };
boolean isOdd(float number) { ... };
En fonction des types de paramètres, la méthode correspondante sera appelée. Notez que changer le type de retour n'est pas suffisant (bien que vous puissiez le faire en plus).
Lorsqu'une méthode est remplacée, la nouvelle méthode a la même signature et remplace la méthode substituée dans certains cas. Voici un exemple de méthode remplacée:
public class A
{
public void someMethod() { ... }
}
public class B extends A
{
public void someMethod() { ... }
}
Le choix se fait en fonction du type d'objet. Par exemple,
A someA = new B();
someA.someMethod();
appellera le someMethod de B. Vous pouvez (et devez) ajouter l'annotation @Override:
public class B extends A
{
@Override
public void someMethod() { ... }
}
Maintenant, si vous modifiez accidentellement les paramètres dans B, le compilateur vous informera que vous ne remplacez pas someMethod () mais que vous le surchargez.
Surcharge, les méthodes ont le même nom mais des paramètres différents.
Surcharge, l'implémentation donnée dans la classe de base est remplacée par celle dans la sous-classe.
Les concepts que vous demandez sont traités dans les didacticiels Java.
Explication de la substitution est donné comme suit:
Une méthode d'instance dans une sous-classe avec la même signature (nom, plus le numéro et le type de ses paramètres) et retourne le type comme méthode d'instance dans la superclasse remplace la méthode de la superclasse.
La capacité d'une sous-classe à remplacer une méthode permet à une classe d'hériter d'une superclasse dont le comportement est "assez proche", puis de modifier le comportement selon les besoins. La méthode de remplacement a le même nom, le même nombre et le même type de paramètres et renvoie le même type que la méthode qu'elle remplace. Une méthode de substitution peut également renvoyer un sous-type du type renvoyé par la méthode substituée. C'est ce qu'on appelle un type de retour covariant.
Lors de la substitution d'une méthode, vous souhaiterez peut-être utiliser le
@Overrideannotation qui indique au compilateur que vous avez l'intention de remplacer une méthode dans la superclasse. Si, pour une raison quelconque, le compilateur détecte que la méthode n'existe pas dans l'une des superclasses, il générera une erreur. Pour plus d'informations sur@Override, voir Annotations ...
La surcharge est expliquée dans le tutoriel comme suit:
Le langage de programmation Java prend en charge les méthodes de surcharge, et Java peut distinguer les méthodes avec des signatures de méthode différentes. Cela signifie que les méthodes d'une classe peuvent avoir le même nom si ils ont des listes de paramètres différentes (il y a quelques qualifications à cela qui seront discutées dans la leçon intitulée "Interfaces et héritage".
Supposons que vous ayez une classe qui peut utiliser la calligraphie pour dessiner différents types de données (chaînes, entiers, etc.) et qui contient une méthode pour dessiner chaque type de données. Il est fastidieux d'utiliser un nouveau nom pour chaque méthode, par exemple
drawString,drawInteger,drawFloat, etc. Dans le langage de programmation Java, vous pouvez utiliser le même nom pour toutes les méthodes de dessin, mais passer une liste d'arguments différente à chaque méthode. Ainsi, la classe de dessin de données peut déclarer quatre méthodes nomméesdraw, dont chacun a une liste de paramètres différente ...Les méthodes surchargées sont différenciées par le nombre et le type des arguments passés dans la méthode ...
Vous ne pouvez pas déclarer plusieurs méthodes avec le même nom et le même nombre et type d'arguments, car le compilateur ne peut pas les différencier.
Le compilateur ne prend pas en compte le type de retour lors de la différenciation des méthodes, vous ne pouvez donc pas déclarer deux méthodes avec la même signature même si elles ont un type de retour différent.
Remarque: Les méthodes surchargées doivent être utilisées avec parcimonie, car elles peuvent rendre le code beaucoup moins lisible.
L'explication ci-dessus pour la surcharge mentionne qualifications discuté dans la leçon intitulée "Interfaces et héritage" :
Dans une sous-classe, vous pouvez surcharger les méthodes héritées de la superclasse. De telles méthodes surchargées ne masquent ni ne remplacent les méthodes de la superclasse - ce sont de nouvelles méthodes, uniques à la sous-classe.
La surcharge d'une méthode est généralement définie comme "fournir plusieurs méthodes disponibles avec le même nom, différant par le nombre et le type d'entrées et de sorties". Le concept est généralement que vous voulez être en mesure d'effectuer la même opération de base compte tenu des différents ensembles d'entrées: vous pouvez, par exemple, "ajouter" deux valeurs de type numérique, mais il est généralement important de savoir quel est le type exact de la valeur est telle que vous pouvez profiter ou planifier des comportements spécifiques de ce type. En tant que tel, vous définiriez une méthode pour chaque combinaison de types numériques (et/ou collections) que vous souhaitez prendre en charge. Toutes ces méthodes ont le même nom, mais des "signatures" différentes; au moment de la compilation, le compilateur fera correspondre un appel à un nom de méthode particulier avec une combinaison donnée d'entrées à un pointeur spécifique dans la mémoire d'application utilisée pour stocker le code.
Le remplacement d'une méthode est généralement défini comme "fournissant une implémentation différente dans une classe dérivée d'une méthode avec une signature particulière définie dans la classe de base". Il existe de nombreuses raisons de remplacer une méthode; pratiquement tous ont en commun le fait que la classe dérivée a une connaissance supplémentaire de ce qui doit être fait, ce qui ne peut pas être connu par la classe de base. Il existe deux variantes de substitution dans la plupart des OO langues; la substitution peut remplacer la méthode de la classe de base, ou elle peut étendre la méthode de la classe de base . La différence est généralement qu'une classe dérivée qui étend une implémentation de classe de base appellera la version substituée de la classe de base de la méthode à un moment donné pendant l'exécution de la méthode de substitution. Cela permet aux classes de substitution de "réutiliser" les zones communes de les opérations contenues dans la classe de base.