Exemple d'analyse de la différence entre la surcharge et la réécriture en Java

Cet article utilise des exemples pour analyser en détail la différence entre la surcharge et la réécriture en Java. Les amis intéressés peuvent s'y référer.

1. Surcharge :

(1) La surcharge de méthode est un moyen pour une classe de traiter différents types de données de manière unifiée. Plusieurs fonctions portant le même nom existent en même temps, avec un nombre/type de paramètres différent.
La surcharge est une manifestation du polymorphisme dans une classe.

(2) La surcharge de méthodes Java signifie que vous pouvez créer plusieurs méthodes dans une classe. Elles ont le même nom mais des paramètres et des définitions différents.
Lors de l'appel de méthodes, vous décidez quelle méthode utiliser en fonction du nombre et du type de paramètres qui leur sont transmis. Il s'agit du polymorphisme.

(3) En cas de surcharge, le nom de la méthode doit être le même, mais le type et le numéro du paramètre sont différents, et le type de valeur de retour peut être identique ou différent. Le type de retour ne peut pas être utilisé comme critère pour distinguer les fonctions surchargées.

Ce qui suit est un exemple de surcharge :

package c04.answer;//这是包名
//这是这个程序的第一种编程方法，在main方法中先创建一个Dog类实例，然后在Dog类的构造方法中利用this关键字调用不同的bark方法。
不同的重载方法bark是根据其参数类型的不同而区分的。
//注意：除构造器以外，编译器禁止在其他任何地方中调用构造器。
package c04.answer;
public class Dog {
Dog()
{
this.bark();
}
void bark()//bark()方法是重载方法
{
System.out.println(\"no barking!\");
this.bark(\"female\", 3.4);
}
void bark(String m,double l)//注意：重载的方法的返回值都是一样的，
{
System.out.println(\"a barking dog!\");
this.bark(5, \"China\");
}
void bark(int a,String n)//不能以返回值区分重载方法，而只能以“参数类型”和“类名”来区分
{
System.out.println(\"a howling dog\");
}
public static void main(String[] args)
{
Dog dog = new Dog();
//dog.bark(); [Page]
//dog.bark(\"male\", \"yellow\");
//dog.bark(5, \"China\");

2. Overriding (Overriding)

(1) Polymorphisme entre classe parent et sous-classe, Redéfinir les fonctions de la classe parente. Si une méthode définie dans une sous-classe a le même nom et les mêmes paramètres que sa classe parent, on dit que la méthode est prioritaire. Dans , les sous-classes peuvent hériter des méthodes de la classe parent sans avoir à réécrire les mêmes méthodes.
Mais parfois la sous-classe ne veut pas hériter des méthodes de la classe parent inchangées, mais veut apporter certaines modifications, ce qui nécessite une réécriture des méthodes.
Le remplacement de méthode est également appelé remplacement de méthode.

(2) Si une méthode de la sous-classe a le même nom de méthode, le même type de retour et la même liste de paramètres qu'une méthode de la classe parent, la nouvelle méthode écrasera la méthode d'origine.
Si vous avez besoin de la méthode originale dans la classe parent, vous pouvez utiliser le mot-clé super, qui fait référence à la classe parent de la classe actuelle.

(3) Les droits de modification d'accès aux fonctions de la sous-classe ne peuvent être inférieurs à ceux de la classe parent

Voici un exemple de réécriture :

Concept : le mécanisme ; pour appeler des méthodes objet.

L'histoire intérieure de la liaison dynamique :

1. Le compilateur vérifie le type et le nom de la méthode de la déclaration d'objet pour obtenir toutes les méthodes candidates. Essayez de commenter le test de la classe Base dans l'exemple ci-dessus, et la compilation échouera.
2. Décision de surcharge : le compilateur vérifie le type de paramètre de l'appel de méthode et sélectionne le seul parmi les méthodes candidates ci-dessus (il y aura une conversion de type implicite pendant ce processus).
Si le compilateur en trouve plusieurs ou qu'aucun n'est trouvé, le compilateur signalera une erreur. Essayez de commenter le test (octet b) de la classe Base dans l'exemple ci-dessus, et le résultat en cours d'exécution est 1 1.
3. Si le type de méthode est priavte static final et que Java utilise la compilation statique, le compilateur saura exactement quelle
méthode appeler.
4. Lorsque le programme est en cours d'exécution et utilise la liaison dynamique pour appeler une méthode, la machine virtuelle doit appeler la version de la méthode qui correspond au type réel de l'objet.
Dans l'exemple, le type réel pointé par b est TestOverriding, donc b.test(0) appelle le test de la sous-classe.
Cependant, la sous-classe ne remplace pas test(byte b), donc b.test((byte)0) appelle test(byte b) de la classe parent.
Si vous commentez le (octet b) de la classe parent, le type implicite est converti en int dans la deuxième étape et le test(int i) de la sous-classe est finalement appelé.

3. Résumé de l'apprentissage :

Le polymorphisme est une fonctionnalité de la programmation orientée objet et n'a rien à voir avec les méthodes
Pour faire simple, la même méthode peut modifier les données d'entrée. selon différentes données d'entrée. , effectuez un traitement différent, c'est-à-dire
surcharge de la méthode - avec différentes listes de paramètres (polymorphisme statique)
Lorsque la sous-classe hérite de la même méthode de la classe parent, les données d'entrée sont les pareil, mais lorsque vous produisez une réponse différente de la classe parent, vous devez remplacer la méthode de la classe parent,
c'est-à-dire réécrire la méthode dans la sous-classe - les mêmes paramètres, des implémentations différentes (polymorphisme dynamique)

POO Trois fonctionnalités majeures : l'héritage, le polymorphisme et l'encapsulation.

public class Base
{
void test(int i)
{
System.out.print(i);
}
void test(byte b)
{
System.out.print(b);
}
}
public class TestOverriding extends Base
{
void test(int i)
{
i++;
System.out.println(i);
}
public static void main(String[]agrs)
{
Base b=new TestOverriding();
b.test(0)
b.test((byte)0)
}
}

Le résultat de sortie à ce moment est 1 0, qui est le résultat d'une liaison dynamique au moment de l'exécution.

Le principal avantage de la substitution est la possibilité de définir des caractéristiques uniques à une certaine sous-classe :

publicclassFather{
publicvoidspeak(){
System.out.println(Father);
}
}
publicclassSonextendsFather{
publicvoidspeak(){
System.out.println("son");
}
}

C'est également appelé polymorphisme. Les méthodes de substitution ne peuvent exister que dans des relations d'héritage. remplacez uniquement les méthodes non privées de la classe parent.
Lorsque la méthode speak() de la classe Father est privée dans l'exemple ci-dessus, la classe Son ne peut pas remplacer la méthode speak() de la classe Father. À l'heure actuelle, la méthode speak() de la classe Son est équivalente à une méthode speak() définie. dans la méthode de classe Son.
Une fois que la méthode speak() de la classe Father est définitive, peu importe le moment où la méthode est modifiée par public, protected ou par défaut, la classe Son ne peut pas du tout remplacer la méthode speak() de la classe Father
Lorsque vous essayez de compiler. le code, compilez Le serveur signalera une erreur. Exemple :

publicclassFather{
finalpublicvoidspeak(){
System.out.println("Father");
}
}
publicclassSonextendsFather{
publicvoidspeak(){
System.out.println("son");
}
}//编译器会报错；

Lorsque la méthode speak() de la classe Father est modifiée par défaut, elle ne peut être remplacée que par ses sous-classes dans le même package. Si elle n'est pas dans le même package, elle ne peut pas être remplacée. .

Lorsque la méthode speak() de la classe Father est protégée, elle est non seulement remplacée par ses sous-classes dans le même package, mais peut également être remplacée par des sous-classes de différents packages.

Règles de substitution des méthodes :

1. La liste des paramètres doit être complètement la même que la méthode remplacée, sinon elle ne peut pas être appelée réécriture mais surcharge.
2. Le type de retour doit toujours être le même que le type de retour de la méthode remplacée, sinon cela ne peut pas être appelé écrasement mais surcharge.
3. La limite du modificateur d'accès doit être supérieure au modificateur d'accès de la méthode remplacée (public>protected>default>private)
4. La méthode remplacée ne doit pas lancer une nouvelle exception de vérification ou être plus lourde que l'accès. modificateur de la méthode remplacée. Écrivez des déclarations de méthode qui sont des exceptions vérifiées plus générales. Par exemple :
Une méthode de la classe parent déclare une exception vérifiée IOException. Lors de la substitution de cette méthode, vous ne pouvez pas lancer d'exception. Vous ne pouvez lancer que des exceptions de sous-classes de IOException, et vous pouvez lancer des exceptions non vérifiées.

Les règles de surcharge :

1. Doit avoir des listes de paramètres différentes
2 Vous pouvez avoir des types de retour non blâmants, tant que les listes de paramètres sont différentes ; >3. Peut avoir différents modificateurs d'accès ;
4. Peut lancer différentes exceptions

Bien utiliser la réécriture et la surcharge peut concevoir une classe avec une structure claire et concise. On peut dire que la réécriture et la surcharge jouent un rôle extraordinaire dans le processus d'écriture de code