En Java, le remplacement est une fonctionnalité qui permet à une sous-classe ou à une classe enfant de fournir une implémentation spécifique d'une méthode déjà fournie par l'une de ses super-classes ou classes parentes. Lorsqu'une méthode d'une sous-classe a le même nom, les mêmes paramètres ou signature et le même type de retour (ou sous-type) qu'une méthode de sa super-classe, alors la méthode de la sous-classe est dite passer outre la méthode dans la super-classe.
Le remplacement de méthode est l'un des moyens par lesquels Java parvient à Polymorphisme au moment de l'exécution . La version d'une méthode exécutée sera déterminée par l'objet utilisé pour l'invoquer. Si un objet d'une classe parent est utilisé pour appeler la méthode, alors la version de la classe parent sera exécutée, mais si un objet de la sous-classe est utilisé pour appeler la méthode, alors la version de la classe enfant sera exécutée. Autrement dit, c'est le type de l'objet auquel il est fait référence (pas le type de la variable de référence) qui détermine quelle version d'une méthode remplacée sera exécutée.
Exemple de remplacement de méthode en Java
Vous trouverez ci-dessous l'implémentation du remplacement de méthode Java :
Java
// Java program to demonstrate> // method overriding in java> // Base Class> class> Parent {> >void> show() { System.out.println(>'Parent's show()'>); }> }> // Inherited class> class> Child>extends> Parent {> >// This method overrides show() of Parent> >@Override> void> show()> >{> >System.out.println(>'Child's show()'>);> >}> }> // Driver class> class> Main {> >public> static> void> main(String[] args)> >{> >// If a Parent type reference refers> >// to a Parent object, then Parent's> >// show is called> >Parent obj1 =>new> Parent();> >obj1.show();> >// If a Parent type reference refers> >// to a Child object Child's show()> >// is called. This is called RUN TIME> >// POLYMORPHISM.> >Parent obj2 =>new> Child();> >obj2.show();> >}> }> |
>
>Sortir
Parent's show() Child's show()>
Règles de remplacement des méthodes Java
1. Modificateurs de remplacement et d'accès
Le modificateur d'accès car une méthode prioritaire peut autoriser plus d’accès, mais pas moins, que la méthode remplacée. Par exemple, une méthode d'instance protégée dans la superclasse peut être rendue publique, mais pas privée, dans la sous-classe. Cela générera une erreur de compilation.
Java
// A Simple Java program to demonstrate> // Overriding and Access-Modifiers> class> Parent {> >// private methods are not overridden> >private> void> m1()> >{> >System.out.println(>'From parent m1()'>);> >}> >protected> void> m2()> >{> >System.out.println(>'From parent m2()'>);> >}> }> class> Child>extends> Parent {> >// new m1() method> >// unique to Child class> >private> void> m1()> >{> >System.out.println(>'From child m1()'>);> >}> >// overriding method> >// with more accessibility> >@Override> public> void> m2()> >{> >System.out.println(>'From child m2()'>);> >}> }> // Driver class> class> Main {> >public> static> void> main(String[] args)> >{> >Parent obj1 =>new> Parent();> >obj1.m2();> >Parent obj2 =>new> Child();> >obj2.m2();> >}> }> |
>
>
erreur d'exécutionSortir
From parent m2() From child m2()>
2. Les méthodes finales ne peuvent pas être remplacées
Si nous ne voulons pas qu’une méthode soit surchargée, nous la déclarons comme final . S'il te plait regarde Utiliser Final avec héritage .
Java
// A Java program to demonstrate that> // final methods cannot be overridden> class> Parent {> >// Can't be overridden> >final> void> show() {}> }> class> Child>extends> Parent {> >// This would produce error> >void> show() {}> }> |
>
>
Sortir
13: error: show() in Child cannot override show() in Parent void show() { } ^ overridden method is final> 3. Les méthodes statiques ne peuvent pas être remplacées (Method Overriding vs Method Hiding) :
Lorsque vous définissez une méthode statique avec la même signature qu'une méthode statique dans la classe de base, elle est appelée méthode de masquage . Le tableau suivant résume ce qui se passe lorsque vous définissez une méthode avec la même signature qu'une méthode dans une super-classe.
| Méthode d'instance de superclasse | Méthode statique de superclasse | |
|---|---|---|
| Méthode d'instance de sous-classe | Remplacements | Génère une erreur de compilation |
| Méthode statique de sous-classe | Génère une erreur de compilation | Cache |
Java
combien y a-t-il de villes aux États-Unis d'Amérique
// Java program to show that> // if the static method is redefined by> // a derived class, then it is not> // overriding, it is hiding> class> Parent {> >// Static method in base class> >// which will be hidden in subclass> >static> void> m1()> >{> >System.out.println(>'From parent '> >+>'static m1()'>);> >}> >// Non-static method which will> >// be overridden in derived class> >void> m2()> >{> >System.out.println(> >'From parent '> >+>'non - static(instance) m2() '>);> >}> }> class> Child>extends> Parent {> >// This method hides m1() in Parent> >static> void> m1()> >{> >System.out.println(>'From child static m1()'>);> >}> >// This method overrides m2() in Parent> >@Override> public> void> m2()> >{> >System.out.println(> >'From child '> >+>'non - static(instance) m2() '>);> >}> }> // Driver class> class> Main {> >public> static> void> main(String[] args)> >{> >Parent obj1 =>new> Child();> >// As per overriding rules this> >// should call to class Child static> >// overridden method. Since static> >// method can not be overridden, it> >// calls Parent's m1()> >obj1.m1();> >// Here overriding works> >// and Child's m2() is called> >obj1.m2();> >}> }> |
>
>Sortir
From parent static m1() From child non - static(instance) m2()>
4. Les méthodes privées ne peuvent pas être remplacées
Méthodes privées ne peuvent pas être remplacés car ils sont liés pendant la compilation. Par conséquent, nous ne pouvons même pas remplacer les méthodes privées dans une sous-classe. (Voir ce pour plus de détails).
Java
class> SuperClass {> >private> void> privateMethod()> >{> >System.out.println(> >'This is a private method in SuperClass'>);> >}> >public> void> publicMethod()> >{> >System.out.println(> >'This is a public method in SuperClass'>);> >privateMethod();> >}> }> class> SubClass>extends> SuperClass {> >// This is a new method with the same name as the> >// private method in SuperClass> >private> void> privateMethod()> >{> >System.out.println(> >'This is a private method in SubClass'>);> >}> >// This method overrides the public method in SuperClass> >public> void> publicMethod()> >{> >System.out.println(> >'This is a public method in SubClass'>);> >privateMethod();>// calls the private method in> >// SubClass, not SuperClass> >}> }> public> class> Test {> >public> static> void> main(String[] args)> >{> >SuperClass obj1 =>new> SuperClass();> >obj1.publicMethod();>// calls the public method in> >// SuperClass> >SubClass obj2 =>new> SubClass();> >obj2.publicMethod();>// calls the overridden public> >// method in SubClass> >}> }> |
nombre aléatoire entre 1 et 10
>
>Sortir
This is a public method in SuperClass This is a private method in SuperClass This is a public method in SubClass This is a private method in SubClass>
5. La méthode de substitution doit avoir le même type de retour (ou sous-type)
À partir de Java 5.0, il est possible d'avoir différents types de retour pour une méthode de substitution dans la classe enfant, mais le type de retour de l'enfant doit être un sous-type du type de retour du parent. Ce phénomène est connu sous le nom de type de retour covariant .
Java
class> SuperClass {> >public> Object method()> >{> >System.out.println(> >'This is the method in SuperClass'>);> >return> new> Object();> >}> }> class> SubClass>extends> SuperClass {> >public> String method()> >{> >System.out.println(> >'This is the method in SubClass'>);> >return> 'Hello, World!'>;> >}> }> public> class> Test {> >public> static> void> main(String[] args)> >{> >SuperClass obj1 =>new> SuperClass();> >obj1.method();> >SubClass obj2 =>new> SubClass();> >obj2.method();> >}> }> |
>
>Sortir
This is the method in SuperClass This is the method in SubClass>
6. Invocation d'une méthode remplacée à partir d'une sous-classe
Nous pouvons appeler la méthode de la classe parent dans la méthode de substitution en utilisant le super mot-clé .
Java
// A Java program to demonstrate that overridden> // method can be called from sub-class> // Base Class> class> Parent {> >void> show() { System.out.println(>'Parent's show()'>); }> }> // Inherited class> class> Child>extends> Parent {> >// This method overrides show() of Parent> >@Override> void> show()> >{> >super>.show();> >System.out.println(>'Child's show()'>);> >}> }> // Driver class> class> Main {> >public> static> void> main(String[] args)> >{> >Parent obj =>new> Child();> >obj.show();> >}> }> |
>
>Sortir
Parent's show() Child's show()>
Remplacement et constructeur
Nous ne pouvons pas remplacer le constructeur car les classes parent et enfant ne peuvent jamais avoir de constructeur portant le même nom (le nom du constructeur doit toujours être le même que le nom de la classe).
Remplacement et gestion des exceptions
Vous trouverez ci-dessous deux règles à noter lors du remplacement des méthodes liées à la gestion des exceptions.
Règle 1
Si la méthode substituée par la super-classe ne lève pas d'exception, la méthode substituée par la sous-classe ne peut lancer que l'exception. exception non vérifiée , la levée d'une exception vérifiée entraînera une erreur de compilation.
Java
// Java program to demonstrate overriding when> // superclass method does not declare an exception> class> Parent {> >void> m1() { System.out.println(>'From parent m1()'>); }> >void> m2() { System.out.println(>'From parent m2()'>); }> }> class> Child>extends> Parent {> >@Override> >// no issue while throwing unchecked exception> >void> m1()>throws> ArithmeticException> >{> >System.out.println(>'From child m1()'>);> >}> >@Override> >// compile-time error> >// issue while throwing checked exception> >void> m2()>throws> Exception> >{> >System.out.println(>'From child m2'>);> >}> }> |
>
>
Sortir
error: m2() in Child cannot override m2() in Parent void m2() throws Exception{ System.out.println('From child m2');} ^ overridden method does not throw Exception> Règle n°2
Si la méthode substituée par la superclasse lève une exception, la méthode substituée par la sous-classe ne peut lancer que la même exception de sous-classe. Lancer des exceptions parent dans le Hiérarchie des exceptions entraînera une erreur de compilation. De plus, il n'y a aucun problème si la méthode substituée par la sous-classe ne lève aucune exception.
Java
// Java program to demonstrate overriding when> // superclass method does declare an exception> class> Parent {> >void> m1()>throws> RuntimeException> >{> >System.out.println(>'From parent m1()'>);> >}> }> class> Child1>extends> Parent {> >@Override> >// no issue while throwing same exception> >void> m1()>throws> RuntimeException> >{> >System.out.println(>'From child1 m1()'>);> >}> }> class> Child2>extends> Parent {> >@Override> >// no issue while throwing subclass exception> >void> m1()>throws> ArithmeticException> >{> >System.out.println(>'From child2 m1()'>);> >}> }> class> Child3>extends> Parent {> >@Override> >// no issue while not throwing any exception> >void> m1()> >{> >System.out.println(>'From child3 m1()'>);> >}> }> class> Child4>extends> Parent {> >@Override> >// compile-time error> >// issue while throwing parent exception> >void> m1()>throws> Exception> >{> >System.out.println(>'From child4 m1()'>);> >}> }> |
>
>
javascript le plus proche
Sortir
error: m1() in Child4 cannot override m1() in Parent void m1() throws Exception ^ overridden method does not throw Exception>
Méthode de remplacement et abstraite
Les méthodes abstraites d'une interface ou d'une classe abstraite sont destinées à être remplacées dans les classes concrètes dérivées, sinon une erreur de compilation sera générée.
Méthode de remplacement et synchronisée/strictfp
La présence d'un modificateur synchronisé/strictfp avec la méthode n'a aucun effet sur les règles de remplacement, c'est-à-dire qu'il est possible qu'une méthode synchronisée/strictfp puisse remplacer une méthode non synchronisée/strictfp et vice-versa.
Note:
- En C++, nous avons besoin mot-clé virtuel pour obtenir une dérogation ou Polymorphisme au moment de l'exécution . En Java, les méthodes sont virtuelles par défaut.
- Nous pouvons avoir une substitution de méthode à plusieurs niveaux.
Java
// A Java program to demonstrate> // multi-level overriding> // Base Class> class> Parent {> >void> show() { System.out.println(>'Parent's show()'>); }> }> // Inherited class> class> Child>extends> Parent {> >// This method overrides show() of Parent> >void> show() { System.out.println(>'Child's show()'>); }> }> // Inherited class> class> GrandChild>extends> Child {> >// This method overrides show() of Parent> >void> show()> >{> >System.out.println(>'GrandChild's show()'>);> >}> }> // Driver class> class> Main {> >public> static> void> main(String[] args)> >{> >Parent obj1 =>new> GrandChild();> >obj1.show();> >}> }> |
>
>Sortir
GrandChild's show()>
Remplacement de méthode ou surcharge de méthode
1. Surcharge il s'agit à peu près de la même méthode avec des signatures différentes. La substitution concerne à peu près la même méthode et la même signature mais différentes classes connectées par héritage.
c booléen
2. La surcharge est un exemple de polymorphisme au moment du compilateur et la substitution est un exemple de temps d'exécution polymorphisme .
FAQ sur le remplacement de méthodes Java
T1. Qu’est-ce que le remplacement de méthode ?
Comme indiqué précédemment, les méthodes remplacées permettent à Java de prendre en charge polymorphisme d'exécution . Le polymorphisme est essentiel à la programmation orientée objet pour une raison : il permet à une classe générale de spécifier des méthodes qui seront communes à toutes ses dérivées tout en permettant aux sous-classes de définir l'implémentation spécifique de tout ou partie de ces méthodes. Les méthodes remplacées sont une autre manière par laquelle Java implémente l'aspect une interface et plusieurs méthodes du polymorphisme. Envoi de méthode dynamique est l’un des mécanismes les plus puissants que la conception orientée objet apporte à la réutilisation et à la robustesse du code. La possibilité d'exister des bibliothèques de code pour appeler des méthodes sur des instances de nouvelles classes sans recompilation tout en conservant une interface abstraite propre est un outil extrêmement puissant. Les méthodes remplacées nous permettent d'appeler les méthodes de n'importe laquelle des classes dérivées sans même connaître le type d'objet de classe dérivée.
Q2. Quand appliquer le remplacement de méthode ? (avec exemple)
Remplacer et Héritage : Une partie de la clé pour appliquer avec succès le polymorphisme est de comprendre que les superclasses et les sous-classes forment une hiérarchie qui passe d'une spécialisation moindre à une spécialisation plus grande. Utilisée correctement, la superclasse fournit tous les éléments qu'une sous-classe peut utiliser directement. Il définit également les méthodes que la classe dérivée doit implémenter elle-même. Cela donne à la sous-classe la flexibilité de définir ses méthodes, tout en appliquant une interface cohérente. Ainsi, en combinant l'héritage avec des méthodes surchargées, une superclasse peut définir la forme générale des méthodes qui seront utilisées par l'ensemble de ses sous-classes. Regardons un exemple plus pratique qui utilise la substitution de méthode. Considérons un logiciel de gestion des employés pour une organisation, laissez le code avoir une classe de base simple Employee et la classe a des méthodes comme raiseSalary(), transfer(), Promouvez(), .. etc. Différents types d'employés comme Manager, Engineer, ..etc peuvent avoir leurs implémentations des méthodes présentes dans la classe de base Employee. Dans notre logiciel complet, il suffit de faire passer une liste d'employés partout et d'appeler les méthodes appropriées sans même connaître le type d'employé. Par exemple, nous pouvons facilement augmenter le salaire de tous les employés en parcourant la liste des employés. Chaque type d'employé peut avoir sa logique dans sa classe, nous n'avons pas à nous inquiéter car si raiseSalary() est présente pour un type d'employé spécifique, seule cette méthode serait appelée.
Java
// Java program to demonstrate application>// of overriding in Java>// Base Class>class>Employee {>>public>static>int>base =>10000>;>>int>salary() {>return>base; }>}>// Inherited class>class>Manager>extends>Employee {>>// This method overrides salary() of Parent>>int>salary() {>return>base +>20000>; }>}>// Inherited class>class>Clerk>extends>Employee {>>// This method overrides salary() of Parent>>int>salary() {>return>base +>10000>; }>}>// Driver class>class>Main {>>// This method can be used to print the salary of>>// any type of employee using base class reference>>static>void>printSalary(Employee e)>>{>>System.out.println(e.salary());>>}>>public>static>void>main(String[] args)>>{>>Employee obj1 =>new>Manager();>>// We could also get type of employee using>>// one more overridden method.loke getType()>>System.out.print(>'Manager's salary : '>);>>printSalary(obj1);>>Employee obj2 =>new>Clerk();>>System.out.print(>'Clerk's salary : '>);>>printSalary(obj2);>>}>}>>>SortirManager's salary : 30000 Clerk's salary : 20000>
Article associé
- Répartition de méthode dynamique ou polymorphisme d'exécution en Java
- Remplacement de la méthode equals() de la classe Object
- Remplacement de la méthode toString() de la classe Object
- Surcharge en Java
- Sortie du programme Java | Ensemble 18 (remplacement)