Menu

Java @override: remplacement de méthode et polymorphisme d'exécution

  • Principal
  • Autre
  • Java @override: remplacement de méthode et polymorphisme d'exécution

java override method overriding

Essayez Notre Instrument Pour Éliminer Les Problèmes

Ce didacticiel explique comment réaliser le polymorphisme d'exécution en Java à l'aide du remplacement de méthode et de l'annotation @override avec des exemples simples:

Nous avons déjà discuté en détail du concept de polymorphisme et du polymorphisme à la compilation. Dans ce tutoriel, nous allons continuer avec le polymorphisme Runtime en Java.

Contrairement au polymorphisme à la compilation dans lequel l'appel de méthode est résolu au moment de la compilation, dans le polymorphisme à l'exécution, l'appel de méthode est résolu à l'exécution.

=> Consultez TOUS les didacticiels Java ici.

Remplacement de la méthode @override_ en Java

Ce que vous apprendrez:

Polymorphisme d'exécution en Java

Un polymorphisme d'exécution également connu sous le nom de polymorphisme dynamique ou Distribution de méthode dynamique est un technique dans laquelle un appel de méthode surchargé est résolu dynamiquement au moment de l'exécution.

Le polymorphisme d'exécution en Java est obtenu en utilisant ' remplacement de méthode ». Le remplacement de méthode est une technique par laquelle une méthode de la classe parent est redéfinie ou remplacée dans la classe enfant.

Lorsque la méthode est remplacée dans une classe, la technique de répartition de méthode dynamique résout l'appel de méthode surchargée au moment de l'exécution et non au moment de la compilation.

Réaliser un polymorphisme d'exécution en Java - Remplacement de méthode

Le remplacement de méthode est l'approche que nous utilisons pour obtenir un polymorphisme d'exécution en Java. Comme déjà mentionné, le remplacement de méthode est une technique dans laquelle la sous-classe ajoute une méthode qui est déjà présente dans sa classe parente et ajoute de nouvelles fonctionnalités à cette méthode. Ensuite, nous disons que la méthode de la classe de base est remplacée.

La nouvelle méthode que nous avons définie dans la sous-classe avec le même prototype que la méthode de la classe parente mais une implémentation différente est appelée « méthode de remplacement ' . La méthode de la classe parent est connue sous le nom de ' Méthode remplacée ».

questions et réponses d'entrevue SQL de base pour les novices

Une fois la méthode remplacée, la question demeure de savoir comment l'appel à cette méthode remplacée est résolu?

Nous appelons généralement la méthode surchargée via la référence de la classe de base. Nous allons créer une référence de type base puis attribuer un objet de classe enfant à l'aide du mot-clé new.

Ainsi, cela dépend du contenu de la variable de référence ou de l'objet référencé par la référence de classe de base qui détermine quelle méthode doit être appelée. Ainsi, si les objets de référence pointent vers l'objet de la classe enfant, la méthode de substitution est appelée.

Sinon, si l'objet de référence contient un objet de classe de base, la méthode remplacée est appelée. Un sujet que nous devons être clair dans le polymorphisme d'exécution, en particulier pour la distribution de méthodes dynamiques, est «Upcasting» qui est expliqué ci-dessous.

Upcasting

Lorsqu'un objet de référence de la classe parente dont nous avons discuté ci-dessus pointe ou fait référence à l'objet de la sous-classe, alors nous l'appelons Upcasting.

Upcasting

Expliquons la remontée en utilisant un exemple simple.

Considérez que nous avons une classe «BaseClass» et nous étendons cette BaseClass pour créer une nouvelle classe DerivedClass. Cette structure ressemble à celle ci-dessous.

class BaseClass { ….//BaseClass code here } class DerivedClass extends BaseClass{ ….//DerivedClass code here }

Maintenant, pour implémenter l'upcasting, nous allons déclarer une variable de référence de type BaseClass. Ensuite, nous affectons un objet de DerivedClass à la référence de la classe BaseClass comme indiqué dans l'instruction de code ci-dessous.

BaseClass base = new DerivedClass (); //Upcasting

Nous pouvons donc dire ici que nous avons converti l'objet DerivedClass en BaseClass. En ce qui concerne le polymorphisme d'exécution, le concept d'upcasting est très important.

Ainsi, en général, la conversion ascendante est le processus d'affectation d'objets enfants ou sous-classes à la référence d'un parent ou d'une superclasse.

SuperClass reference = new Subclass Object;

Le programme Java ci-dessous illustre le remplacement de méthode et montre également comment la conversion ascendante est effectuée pour résoudre les appels de méthode remplacés au moment de l'exécution.

//base/parent class class Parent { void Print() //print method { System.out.println('Parent::Print() method'); } } //child class 1 inheriting from Parent class child1 extends Parent { void Print() //overridden print method { System.out.println('child1::Print() method'); } } //child class 2 inheriting from Parent class child2 extends Parent { void Print() //overridden print method { System.out.println('child2::Print() method'); } } class Main { public static void main(String() args) { Parent parent = new Parent(); parent.Print(); //executes parent Print () method parent = new child1(); //upcasting parent.Print(); //executes child1 Print () method parent = new child2(); //upcasting parent.Print(); //executes child2 Print () method

Production:

Upcasting - sortie

Dans le programme ci-dessus, nous avons deux classes, à savoir child1 et child2, qui sont toutes deux dérivées d’une classe «Parent». La classe parente a une méthode «Print» qui est remplacée dans les classes enfant1 et enfant2. Ensuite, dans la méthode principale, nous créons un objet de référence de la classe Parent nommé «parent».

Tout d'abord, nous lui attribuons un objet de la classe Parent, puis appelons la méthode «Print ()». Ensuite, nous répétons cela en affectant d'abord l'objet child1, puis l'objet child2 à la référence Parent.

fusionner un tableau c ++ de tri

La sortie s'affiche, en fonction du contenu de la référence parent, et la méthode d'impression appropriée est appelée.

Avantages du polymorphisme dynamique / d'exécution

  • Avec le polymorphisme dynamique, le programmeur est autorisé à remplacer les méthodes.
  • Il permet aux classes de définir une méthode avec une implémentation générale que ses dérivés peuvent ensuite surcharger et fournir l'implémentation spécifique.
  • Avec la distribution de méthode dynamique, l'appel de méthode est résolu au moment de l'exécution, contrairement à la surcharge qui est décidée au moment de la compilation. Cela permet plus de flexibilité pour les programmeurs.

Comme le polymorphisme d'exécution lie la méthode appropriée à l'appel au moment de l'exécution et nous l'appelons également liaison dynamique ou liaison tardive . Le polymorphisme à la compilation, en revanche, prend en charge liaison statique ou liaison anticipée .

Liaison statique ou dynamique

Reliure statiqueLiaison dynamique
L'appel de méthode résolu au moment de la compilation est une liaison statique.L'appel de méthode résolu au moment de l'exécution est une liaison dynamique.
La surcharge de méthode est un exemple de liaison statique.Le remplacement de méthode est un exemple de liaison dynamique.
Les types de classe et de champ sont utilisés pour la liaison statique.Les objets sont utilisés pour la liaison dynamique.
Les entités privées, finales et statiques utilisent la liaison statique.Les méthodes virtuelles utilisent la liaison dynamique.

Fonction / méthode virtuelle en Java

Une fonction ou méthode virtuelle en Java est une fonctionnalité utilisée avec le polymorphisme d'exécution. Contrairement au C ++, Java n’a pas de mot-clé «virtuel» spécial pour indiquer qu'une méthode est virtuelle. Une méthode définie dans la classe de base et remplacée dans la classe dérivée est virtuelle.

En Java, par défaut, chaque méthode non statique à l'exception de private et final est une fonction virtuelle. Notez donc que les méthodes dont nous avons discuté ci-dessus remplaçant pour implémenter le polymorphisme d'exécution sont également des méthodes virtuelles.

Comme la méthode statique est liée à Class et ne peut pas être appelée à l'aide d'un objet, elle ne peut pas être utilisée avec le polymorphisme d'exécution et ce n'est pas non plus une fonction virtuelle.

Les interfaces en Java sont par défaut virtuelles. Les classes implémentant des interfaces fournissent des implémentations pour les méthodes d'interface. Comme dans le polymorphisme à l'exécution, l'appel aux méthodes d'interface est également résolu à l'exécution.

N'oubliez pas que puisque les méthodes d'une interface sont conçues pour être remplacées, toutes les méthodes d'interface sont des fonctions virtuelles.

Par exemple, considérez le code suivant:

interface car{ void accelerate(); } class Maruti implements car{ void accelerate () { System.out.println(“Maruti car accelerated!!”); } }

Dans le code ci-dessus, la méthode accelerate () est une fonction virtuelle car elle fait partie de la voiture d'interface et est conçue pour être remplacée.

Annotation @override en Java

L'annotation @override est l'annotation par défaut dans Java. Cette annotation a été introduite dans Java 1.5. L'annotation @override est utilisée lorsque la méthode de sous-classe remplace sa méthode de superclasse.

En utilisant l'annotation Java @override pour indiquer que la méthode remplace sa méthode de classe parente, un compilateur émet un avertissement si la méthode annotée n'est pas remplacée. Ainsi, il est obligatoire que la méthode soit remplacée lorsque l'annotation @override est utilisée.

Deuxièmement, en utilisant l'annotation @override, nous rendons le code plus lisible. Nous pouvons tout de suite réaliser que la méthode déclarée doit être surchargée.

La syntaxe générale de l'annotation Java @override est

public @interface override

Le programme Java ci-dessous montre l'utilisation de l'annotation @override.

//base class definition class BaseClass { public void display() { System.out.println('BaseClass::display () method'); } } //derived class inheriting base class class DerivedClass extends BaseClass { @Override //indicates the display method being overridden public void display() { System.out.println('DerivedClass::display () method'); } } // main class public class Main { public static void main(String args()) { System.out.println('@Override Example'); //BaseClass type object;contain child object BaseClass testObj = new DerivedClass(); //call display method based on contents of object i.e. derived class display () testObj.display(); } }

Production:

Exemple @Override

Dans le programme ci-dessus, nous avons une BaseClass qui définit une méthode d'affichage. Ensuite, nous dérivons une classe DerivedClass de cette BaseClass et marquons la méthode d'affichage avec l'annotation @override. Cette méthode est remplacée dans DerivedClass.

Dans la méthode principale, nous créons une référence d'objet BaseClass et la pointons vers l'objet DerivedClass qui oblige la référence à appeler la méthode d'affichage DerivedClass.

Si nous n'avions pas implémenté la méthode display () dans la classe Derived, le compilateur aurait donné un avertissement au compilateur car il est marqué par l'annotation @override.

Surcharge et remplacement en Java

Maintenant que nous avons discuté de la surcharge et du remplacement en Java, résumons ces deux concepts.

La surcharge est liée au polymorphisme au moment de la compilation, c'est-à-dire que nous implémentons le polymorphisme au moment de la compilation en utilisant la surcharge. La surcharge se fait de deux manières, à savoir la surcharge de méthode et la surcharge de l'opérateur.

La surcharge de méthode est la technique dans laquelle nous avons plus d'une méthode avec le même nom mais des listes de paramètres différentes. La liste des paramètres est différenciée en fonction du nombre de paramètres, des types de paramètres ou de la séquence de paramètres.

La surcharge des opérateurs en Java est limitée et nous permet de surcharger uniquement l'opérateur «+» qui est utilisé pour ajouter deux nombres et concaténer deux objets String.

La surcharge est résolue au moment de la compilation et est statique. Il est également appelé «Early binding» .

Le remplacement de méthode est une fonctionnalité à l'aide de laquelle nous implémentons le polymorphisme d'exécution. Dans le remplacement de méthode, une méthode de la classe parente est remplacée dans la classe enfant. Cela signifie que le prototype de méthode dans la super et la sous-classe reste le même mais les implémentations sont différentes.

Le remplacement de méthode utilise la technique de répartition de méthode dynamique pour résoudre l'appel de méthode et décider s'il faut appeler une méthode de superclasse ou de sous-classe, ce qui est fait au moment de l'exécution.

Par conséquent, le polymorphisme d'exécution est également appelé polymorphisme dynamique ou liaison tardive.

Ensuite, nous allons tabulariser les différences entre la surcharge et le remplacement en Java.

Surcharge vs remplacement en Java

SurchargePrimordial
La surcharge est utilisée dans le polymorphisme à la compilation.Le remplacement est implémenté dans le polymorphisme d'exécution.
Peut être fait dans la même classe. Peut ou non exiger l'héritage.Le remplacement nécessite toujours un héritage.
Les méthodes sont surchargées avec le même nom de méthode et une liste de paramètres différente.Les méthodes remplacées ont les mêmes prototypes.
Le type de retour n'est pas pris en compte dans la surcharge de méthode.Le type de retour doit être le même dans les méthodes remplacées et remplacées.
Améliore la lisibilité du programme.Le remplacement permet d'avoir une classe d'implémentation spécifique.

Questions fréquemment posées

Q # 1) Pouvons-nous remplacer la méthode statique?

Répondre: Non. Les méthodes statiques ne peuvent pas être remplacées en Java. Cela est dû au fait que les méthodes statiques sont basées sur des classes et sont appelées directement par la classe. Ils n’ont pas besoin d’objets à appeler lors de l’exécution. Par conséquent, la répartition de la méthode statique est déterminée par le compilateur.

Q # 2) Pouvons-nous remplacer le constructeur?

Répondre: Non, nous ne pouvons pas remplacer un constructeur. Un constructeur est appelé lors de la création de l'objet. Cela ne s'appelle pas un objet. En outre, l'une des exigences de la substitution est la méthode remplacée et la méthode de remplacement doit avoir la même signature de méthode, ce qui n'est pas possible dans le cas des constructeurs.

Q # 3) Pourquoi la substitution de méthode est-elle appelée polymorphisme dynamique?

Répondre: Dans le cas d'une substitution de méthode, l'appel de méthode est résolu dynamiquement au moment de l'exécution. Par conséquent, il est appelé polymorphisme dynamique.

Q # 4) Quelle est l'utilisation du polymorphisme dynamique en Java?

Répondre: Le polymorphisme dynamique utilise une technique de répartition de méthode dynamique qui prend en charge le remplacement de méthode afin que la sous-classe puisse fournir une implémentation spécifique à la méthode remplacée. De cette façon, nous pouvons implémenter les fonctionnalités spécifiques qui nous permettent d'écrire des programmes efficaces.

Deuxièmement, nous n'avons pas non plus à nous soucier de la résolution des appels de méthode car la répartition dynamique des méthodes décide de la méthode à appeler.

Q # 5) Quelle est la différence entre la liaison statique et dynamique?

Répondre: La liaison entre un appel de méthode et son implémentation est appelée liaison. Lorsque cette liaison est résolue au moment de la compilation, nous l'appelons liaison statique. Lorsque la liaison est effectuée dynamiquement au moment de l'exécution, nous l'appelons comme liaison dynamique.

La liaison statique utilise le type de données de la classe et des champs pour résoudre les appels de méthode. La liaison dynamique utilise des objets pour résoudre les appels de méthode. La liaison statique est également appelée polymorphisme à la compilation et la liaison dynamique est également appelée polymorphisme à l'exécution.

Conclusion

Dans ce tutoriel, nous avons discuté en détail du polymorphisme d'exécution en Java.

Le polymorphisme d'exécution est implémenté en utilisant le remplacement de méthode. Le remplacement de méthode est effectué dans la sous-classe dans laquelle une méthode définie dans la superclasse est redéfinie ou remplacée dans sa sous-classe. La signature de méthode reste la même dans la super et la sous-classe.

En utilisant la substitution de méthode, nous pouvons fournir une implémentation spécifique à la même méthode dans la sous-classe. De cette façon, nous pouvons écrire des programmes plus efficaces qui impliquent l'héritage. Java fournit l'annotation @override pour indiquer que la méthode doit être remplacée.

comment ouvrir les fichiers .jnlp

Par défaut, toutes les méthodes non statiques qui ne sont pas définitives sont virtuelles en Java. Toutes les méthodes virtuelles peuvent être remplacées.

=> Regardez la série de formation Java simple ici.

lecture recommandée

^