In Java ist Overriding eine Funktion, die es einer Unterklasse oder untergeordneten Klasse ermöglicht, eine bestimmte Implementierung einer Methode bereitzustellen, die bereits von einer ihrer Superklassen oder übergeordneten Klassen bereitgestellt wird. Wenn eine Methode in einer Unterklasse denselben Namen, dieselben Parameter oder dieselbe Signatur und denselben Rückgabetyp (oder Untertyp) wie eine Methode in ihrer Oberklasse hat, spricht man von der Methode in der Unterklasse überschreiben die Methode in der Superklasse.
Das Überschreiben von Methoden ist eine der Möglichkeiten, mit denen Java dies erreicht Laufzeitpolymorphismus . Die Version einer Methode, die ausgeführt wird, wird durch das Objekt bestimmt, das zum Aufrufen verwendet wird. Wenn ein Objekt einer übergeordneten Klasse zum Aufrufen der Methode verwendet wird, wird die Version in der übergeordneten Klasse ausgeführt. Wenn jedoch ein Objekt der Unterklasse zum Aufrufen der Methode verwendet wird, wird die Version in der untergeordneten Klasse ausgeführt. Mit anderen Worten, Es ist der Typ des Objekts, auf das verwiesen wird (nicht der Typ der Referenzvariablen), der bestimmt, welche Version einer überschriebenen Methode ausgeführt wird.
Beispiel für das Überschreiben von Methoden in Java
Nachfolgend finden Sie die Implementierung des 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();> >}> }> |
>
>Ausgabe
Parent's show() Child's show()>
Regeln für das Überschreiben von Java-Methoden
1. Überschreibungs- und Zugriffsmodifikatoren
Der Zugriffsmodifikator denn eine überschreibende Methode kann mehr, aber nicht weniger Zugriff erlauben als die überschriebene Methode. Beispielsweise kann eine geschützte Instanzmethode in der Oberklasse in der Unterklasse öffentlich, aber nicht privat gemacht werden. Andernfalls wird ein Fehler bei der Kompilierung generiert.
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();> >}> }> |
>
>Ausgabe
From parent m2() From child m2()>
2. Endgültige Methoden können nicht überschrieben werden
Wenn wir nicht möchten, dass eine Methode überschrieben wird, deklarieren wir sie als Finale . Bitte sehen Final mit Vererbung verwenden .
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() {}> }> |
>
>
Ausgabe
13: error: show() in Child cannot override show() in Parent void show() { } ^ overridden method is final> 3. Statische Methoden können nicht überschrieben werden (Überschreiben von Methoden vs. Ausblenden von Methoden):
Wenn Sie eine statische Methode mit derselben Signatur wie eine statische Methode in der Basisklasse definieren, wird sie als bezeichnet Methode versteckt . Die folgende Tabelle fasst zusammen, was passiert, wenn Sie eine Methode mit derselben Signatur wie eine Methode in einer Superklasse definieren.
| Superklassen-Instanzmethode | Statische Methode der Superklasse | |
|---|---|---|
| Unterklasseninstanzmethode | Überschreibt | Erzeugt einen Fehler bei der Kompilierung |
| Statische Methode der Unterklasse | Erzeugt einen Fehler bei der Kompilierung | Versteckt |
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();> >}> }> |
>
>Ausgabe
From parent static m1() From child non - static(instance) m2()>
4. Private Methoden können nicht überschrieben werden
Private Methoden können nicht überschrieben werden, da sie während der Kompilierungszeit gebunden werden. Daher können wir nicht einmal private Methoden in einer Unterklasse überschreiben. (Siehe Das für Details).
char zu string java
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> >}> }> |
>
>Ausgabe
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. Die überschreibende Methode muss denselben Rückgabetyp (oder Subtyp) haben.
Ab Java 5.0 ist es möglich, unterschiedliche Rückgabetypen für eine überschreibende Methode in der untergeordneten Klasse zu haben, der Rückgabetyp des untergeordneten Elements sollte jedoch ein Untertyp des Rückgabetyps des übergeordneten Elements sein. Dieses Phänomen ist als bekannt kovarianter Rückgabetyp .
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();> >}> }> |
>
>Ausgabe
This is the method in SuperClass This is the method in SubClass>
6. Aufrufen einer überschriebenen Methode aus der Unterklasse
Wir können die übergeordnete Klassenmethode in der überschreibenden Methode mit aufrufen Super-Schlüsselwort .
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();> >}> }> |
>
>Ausgabe
Parent's show() Child's show()>
Überschreiben und Konstruktor
Wir können den Konstruktor nicht überschreiben, da die übergeordnete und untergeordnete Klasse niemals einen Konstruktor mit demselben Namen haben können (der Konstruktorname muss immer mit dem Klassennamen identisch sein).
Überschreiben und Ausnahmebehandlung
Im Folgenden finden Sie zwei Regeln, die Sie beim Überschreiben von Methoden im Zusammenhang mit der Ausnahmebehandlung beachten sollten.
Regel 1
Wenn die überschriebene Methode der Oberklasse keine Ausnahme auslöst, kann die überschreibende Methode der Unterklasse nur die Ausnahme auslösen ungeprüfte Ausnahme , führt das Auslösen einer geprüften Ausnahme zu einem Fehler bei der Kompilierung.
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'>);> >}> }> |
>
>
Ausgabe
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 Nr. 2
Wenn die überschriebene Methode der Oberklasse eine Ausnahme auslöst, kann die überschreibende Methode der Unterklasse nur dieselbe Ausnahme der Unterklasse auslösen. Auslösen von übergeordneten Ausnahmen im Ausnahmehierarchie führt zu einem Fehler bei der Kompilierung. Außerdem gibt es kein Problem, wenn die überschriebene Methode der Unterklasse keine Ausnahme auslöst.
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()'>);> >}> }> |
>
>
Ausgabe
error: m1() in Child4 cannot override m1() in Parent void m1() throws Exception ^ overridden method does not throw Exception>
Überschreibende und abstrakte Methode
Abstrakte Methoden in einer Schnittstelle oder abstrakten Klasse sollen in abgeleiteten konkreten Klassen überschrieben werden, andernfalls wird ein Fehler bei der Kompilierung ausgegeben.
Überschreibende und synchronisierte/strictfp-Methode
Das Vorhandensein eines synchronisierten/strictfp-Modifizierers in der Methode hat keinen Einfluss auf die Regeln zum Überschreiben, d. h. es ist möglich, dass eine synchronisierte/strictfp-Methode eine nicht synchronisierte/strictfp-Methode überschreiben kann und umgekehrt.
Notiz:
- In C++ brauchen wir virtuelles Schlüsselwort übergeordnetes Ziel erreichen bzw Laufzeitpolymorphismus . In Java sind Methoden standardmäßig virtuell.
- Wir können Methodenüberschreibungen auf mehreren Ebenen durchführen.
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();> >}> }> |
numpy einzigartig
>
>Ausgabe
GrandChild's show()>
Methodenüberschreibung vs. Methodenüberladung
1. Überlastung handelt es sich um die gleiche Methode mit unterschiedlichen Signaturen. Beim Überschreiben geht es um dieselbe Methode und dieselbe Signatur, aber um unterschiedliche Klassen, die durch Vererbung verbunden sind.
2. Überladen ist ein Beispiel für Polymorphismus zur Compilerzeit und Überschreiben ist ein Beispiel für Laufzeit Polymorphismus .
FAQs zum Überschreiben von Java-Methoden
Q1. Was ist Methodenüberschreibung?
Wie bereits erwähnt, ermöglichen überschriebene Methoden die Unterstützung von Java Laufzeitpolymorphismus . Polymorphismus ist aus einem Grund für die objektorientierte Programmierung unerlässlich: Er ermöglicht einer allgemeinen Klasse, Methoden anzugeben, die allen ihren Derivaten gemeinsam sind, während Unterklassen die spezifische Implementierung einiger oder aller dieser Methoden definieren können. Überschriebene Methoden sind eine weitere Möglichkeit, wie Java den Aspekt des Polymorphismus mit einer Schnittstelle und mehreren Methoden implementiert. Dynamischer Methodenversand ist einer der leistungsstärksten Mechanismen, die objektorientiertes Design für die Wiederverwendung und Robustheit von Code bietet. Die Möglichkeit, Codebibliotheken zu erstellen, um Methoden für Instanzen neuer Klassen ohne Neukompilierung aufzurufen und gleichzeitig eine saubere abstrakte Schnittstelle beizubehalten, ist ein äußerst leistungsstarkes Werkzeug. Überschriebene Methoden ermöglichen es uns, Methoden jeder abgeleiteten Klasse aufzurufen, ohne den Typ des abgeleiteten Klassenobjekts zu kennen.
Q2. Wann sollte Methodenüberschreibung angewendet werden? (mit Beispiel)
Überschreiben und Nachlass : Ein Schlüssel zur erfolgreichen Anwendung von Polymorphismus liegt darin, zu verstehen, dass die Oberklassen und Unterklassen eine Hierarchie bilden, die von geringerer zu größerer Spezialisierung übergeht. Richtig eingesetzt stellt die Oberklasse alle Elemente bereit, die eine Unterklasse direkt nutzen kann. Außerdem werden die Methoden definiert, die die abgeleitete Klasse selbst implementieren muss. Dies gibt der Unterklasse die Flexibilität, ihre Methoden zu definieren und erzwingt dennoch eine konsistente Schnittstelle. Durch die Kombination von Vererbung mit überschriebenen Methoden kann eine Oberklasse somit die allgemeine Form der Methoden definieren, die von allen ihren Unterklassen verwendet werden. Schauen wir uns ein praktischeres Beispiel an, das das Überschreiben von Methoden verwendet. Stellen Sie sich eine Mitarbeiterverwaltungssoftware für eine Organisation vor. Der Code verfügt über eine einfache Basisklasse „Employee“ und die Klasse verfügt über Methoden wie raiseSalary(), transfer(), promote() usw. Verschiedene Arten von Mitarbeitern wie Manager, Ingenieur, ..etc kann ihre Implementierungen der Methoden in der Basisklasse Employee enthalten. In unserer vollständigen Software müssen wir lediglich eine Liste von Mitarbeitern überall weitergeben und entsprechende Methoden aufrufen, ohne den Typ des Mitarbeiters überhaupt zu kennen. Beispielsweise können wir das Gehalt aller Mitarbeiter ganz einfach erhöhen, indem wir die Liste der Mitarbeiter durchlaufen. Jeder Mitarbeitertyp kann seine eigene Logik in seiner Klasse haben. Wir müssen uns keine Sorgen machen, denn wenn raiseSalary() für einen bestimmten Mitarbeitertyp vorhanden ist, wird nur diese Methode aufgerufen.
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);>>}>}>>>AusgabeManager's salary : 30000 Clerk's salary : 20000>
Verwandter Artikel
- Dynamischer Methodenversand oder Laufzeitpolymorphismus in Java
- Überschreiben der Methode equal() der Klasse Object
- Überschreiben der toString()-Methode der Object-Klasse
- Überladung in Java
- Ausgabe des Java-Programms | Satz 18 (Überschreiben)