Réponses:
Pour surcharger une méthode avec une nouvelle méthode, la nouvelle méthode doit avoir une signature différente. C'est-à-dire que 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 someMethodde 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.
L'explication de la substitution est donnée 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 super-classe 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 l'
@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 didacticiel comme suit:
Le langage de programmation Java prend en charge les méthodes de surcharge et Java peut faire la distinction entre les méthodes avec différentes signatures de méthode. Cela signifie que les méthodes au sein d'une classe peuvent avoir le même nom si elles ont des listes de paramètres différentes (il y a certaines qualifications à cela qui seront discutées dans la leçon intitulée "Interfaces et héritage".
Supposons que vous disposiez d'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 lourd d'utiliser un nouveau nom pour chaque méthode par exemple
drawString,drawInteger,drawFloatet ainsi de suite. Dans le langage de programmation Java, vous pouvez utiliser le même nom pour toutes les méthodes de dessin mais transmettre 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, chacune ayant 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 les qualifications discutées 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 étant donné 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 de 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 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 types de priorité dans la plupart des langues OO; la substitution peut remplacer la méthode de classe de base, ou elle peut étendrela méthode de 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 redéfinie de la méthode de la classe de base à un moment donné pendant l'exécution de la méthode redéfinie. Cela permet aux classes prioritaires de "réutiliser" les zones communes de l'opération qui sont contenues dans la classe de base.