In Java is Overriding een functie waarmee een subklasse of onderliggende klasse een specifieke implementatie kan bieden van een methode die al wordt geleverd door een van de superklassen of bovenliggende klassen. Wanneer een methode in een subklasse dezelfde naam, dezelfde parameters of handtekening en hetzelfde retourtype (of subtype) heeft als een methode in zijn superklasse, dan wordt gezegd dat de methode in de subklasse overschrijven de methode in de superklasse.
Het overschrijven van methoden is een van de manieren waarop Java resultaten boekt Runtime-polymorfisme . De versie van een methode die wordt uitgevoerd, wordt bepaald door het object dat wordt gebruikt om de methode aan te roepen. Als een object van een bovenliggende klasse wordt gebruikt om de methode aan te roepen, zal de versie in de bovenliggende klasse worden uitgevoerd, maar als een object van de subklasse wordt gebruikt om de methode aan te roepen, zal de versie in de onderliggende klasse worden uitgevoerd. Met andere woorden, het is het type object waarnaar wordt verwezen (niet het type van de referentievariabele) die bepaalt welke versie van een overschreven methode zal worden uitgevoerd.
Voorbeeld van methodeoverschrijving in Java
Hieronder ziet u de implementatie van de Java Method Overriding:
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();> >}> }> |
>
>Uitvoer
Parent's show() Child's show()>
Regels voor het overschrijven van Java-methoden
1. Wijzigingen overschrijven en toegang krijgen
De toegangsmodificator want een overschrijvende methode kan meer, maar niet minder, toegang toestaan dan de overschreven methode. Een beschermde instantiemethode in de superklasse kan bijvoorbeeld openbaar worden gemaakt, maar niet privé, in de subklasse. Als u dit wel doet, wordt er een compileerfout gegenereerd.
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();> >}> }> |
>
>Uitvoer
From parent m2() From child m2()>
2. Definitieve methoden kunnen niet worden overschreven
Als we niet willen dat een methode wordt overschreven, declareren we deze als laatste . Alsjeblieft zie Finale gebruiken met erfenis .
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() {}> }> |
>
>
jlijst
Uitvoer
13: error: show() in Child cannot override show() in Parent void show() { } ^ overridden method is final> 3. Statische methoden kunnen niet worden overschreven (methode overschrijven versus methode verbergen):
Wanneer u een statische methode definieert met dezelfde handtekening als een statische methode in de basisklasse, staat deze bekend als methode verbergen . De volgende tabel vat samen wat er gebeurt als u een methode definieert met dezelfde handtekening als een methode in een superklasse.
| Superklasse-instantiemethode | Superklasse statische methode | |
|---|---|---|
| Subklasse-instantiemethode | Overschrijvingen | Genereert een compileerfout |
| Subklasse statische methode | Genereert een compileerfout | Verbergt |
Java
// 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();> >}> }> |
>
>Uitvoer
From parent static m1() From child non - static(instance) m2()>
4. Privémethoden kunnen niet worden overschreven
Privé methoden kunnen niet worden overschreven, omdat ze tijdens het compileren aan elkaar worden gekoppeld. Daarom kunnen we privémethoden in een subklasse niet eens overschrijven. (Zie dit voor details).
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> >}> }> |
>
>Uitvoer
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. De overschrijvende methode moet hetzelfde retourtype (of subtype) hebben
Vanaf Java 5.0 is het mogelijk om verschillende retourneringstypen te hebben voor een overschrijvende methode in de onderliggende klasse, maar het retourneringstype van het kind moet een subtype zijn van het retourneringstype van de ouder. Dit fenomeen staat bekend als de covariant retourtype .
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();> >}> }> |
>
>Uitvoer
This is the method in SuperClass This is the method in SubClass>
6. Overschreven methode aanroepen vanuit subklasse
We kunnen de ouderklassemethode in de overschrijvende methode aanroepen met behulp van de supertrefwoord .
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();> >}> }> |
>
>Uitvoer
Parent's show() Child's show()>
Overschrijven en constructeur
We kunnen de constructor niet overschrijven, omdat de ouder- en kindklasse nooit een constructor met dezelfde naam kunnen hebben (de constructornaam moet altijd hetzelfde zijn als de klassenaam).
Overschrijven en afhandeling van uitzonderingen
Hieronder staan twee regels waarmee u rekening moet houden bij het overschrijven van methoden die verband houden met de afhandeling van uitzonderingen.
Regel 1
Als de overschreven methode van de superklasse geen uitzondering genereert, kan de overschreven methode van de subklasse alleen de ongecontroleerde uitzondering , zal het genereren van een gecontroleerde uitzondering leiden tot een compileerfout.
Java
latex-lettergrootte
// 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'>);> >}> }> |
>
>
Uitvoer
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> Regel #2
Als de superklasse-overschreven methode een uitzondering genereert, kan de subklasse-overschreven methode alleen dezelfde subklasse-uitzondering genereren. Ouderuitzonderingen in het Uitzonderingshiërarchie zal leiden tot een compileerfout. Er is ook geen probleem als de door de subklasse overschreven methode geen uitzondering genereert.
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()'>);> >}> }> |
>
>
Uitvoer
error: m1() in Child4 cannot override m1() in Parent void m1() throws Exception ^ overridden method does not throw Exception>
Overheersende en abstracte methode
Het is de bedoeling dat abstracte methoden in een interface of abstracte klasse worden overschreven in afgeleide concrete klassen, anders ontstaat er een compileerfout.
Overschrijvende en gesynchroniseerde/strictfp-methode
De aanwezigheid van een gesynchroniseerde/strictfp-modifier bij de methode heeft geen effect op de regels voor het overschrijven, d.w.z. het is mogelijk dat een gesynchroniseerde/strictfp-methode een niet-gesynchroniseerde/strictfp-methode kan overschrijven en omgekeerd.
Opmerking:
- In C++ hebben we nodig virtueel trefwoord om een overheersende of Runtime-polymorfisme . In Java zijn methoden standaard virtueel.
- We kunnen methoden op meerdere niveaus overschrijven.
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();> >}> }> |
>
>
c# bevat tekenreeksUitvoer
GrandChild's show()>
Methode overschrijven versus methode overbelasting
1. Overbelasting gaat over dezelfde methode met verschillende handtekeningen. Overschrijven gaat over dezelfde methode en dezelfde handtekening, maar verschillende klassen die via overerving met elkaar zijn verbonden.
2. Overbelasting is een voorbeeld van polymorfisme tijdens de compiler en overschrijven is een voorbeeld van runtime polymorfisme .
Veelgestelde vragen over het overschrijven van Java-methoden
Q1. Wat is methodeoverschrijving?
Zoals eerder vermeld, zorgen overschreven methoden ervoor dat Java wordt ondersteund runtime polymorfisme . Polymorfisme is om één reden essentieel voor objectgeoriënteerd programmeren: het stelt een algemene klasse in staat methoden te specificeren die gemeenschappelijk zijn voor al zijn afgeleiden, terwijl subklassen de specifieke implementatie van sommige of al deze methoden kunnen definiëren. Overschreven methoden zijn een andere manier waarop Java het aspect van polymorfisme met één interface en meerdere methoden implementeert. Dynamische methodeverzending is een van de krachtigste mechanismen die objectgeoriënteerd ontwerp toepast op hergebruik en robuustheid van code. De mogelijkheid om codebibliotheken te creëren om methoden aan te roepen op instances van nieuwe klassen zonder opnieuw te compileren, terwijl een schone abstracte interface behouden blijft, is een uiterst krachtig hulpmiddel. Overschreven methoden stellen ons in staat methoden van elk van de afgeleide klassen aan te roepen zonder zelfs maar het type afgeleid klasseobject te kennen.
Vraag 2. Wanneer moet u Method Overriding toepassen? (met voorbeeld)
Overschrijven en Erfenis : Een deel van de sleutel tot het succesvol toepassen van polymorfisme is het inzicht dat de superklassen en subklassen een hiërarchie vormen die zich verplaatst van kleinere naar grotere specialisatie. Correct gebruikt, biedt de superklasse alle elementen die een subklasse direct kan gebruiken. Het definieert ook de methoden die de afgeleide klasse zelfstandig moet implementeren. Dit geeft de subklasse de flexibiliteit om zijn methoden te definiëren, maar dwingt toch een consistente interface af. Door overerving te combineren met overschreven methoden kan een superklasse dus de algemene vorm definiëren van de methoden die door al zijn subklassen zullen worden gebruikt. Laten we eens kijken naar een praktischer voorbeeld waarin methode-overschrijving wordt gebruikt. Overweeg software voor personeelsbeheer voor een organisatie, laat de code een eenvoudige basisklasse Employee hebben en de klasse heeft methoden zoals raiseSalary(), transfer(), promote(), .. etc. Verschillende soorten werknemers zoals Manager, Engineer, ..etc kan hun implementaties hebben van de methoden die aanwezig zijn in de basisklasse Werknemer. In onze complete software hoeven we alleen maar een lijst met medewerkers overal door te geven en de juiste methoden aan te roepen zonder zelfs maar het type medewerker te kennen. We kunnen bijvoorbeeld eenvoudig het salaris van alle werknemers verhogen door de lijst met werknemers te doorlopen. Elk type werknemer kan zijn eigen logica in zijn klasse hebben. We hoeven ons geen zorgen te maken, want als raiseSalary() aanwezig is voor een specifiek werknemerstype, zou alleen die methode worden aangeroepen.
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);>>}>}>>>UitvoerManager's salary : 30000 Clerk's salary : 20000>
Gerelateerd artikel
- Dynamische methodeverzending of runtimepolymorfisme in Java
- De methode equals() van de objectklasse wordt overschreven
- Methode toString() van de objectklasse overschrijven
- Overbelasting in Java
- Uitvoer van Java-programma | Set 18 (overschrijven)