Wenn eine Unterklasse eine bestimmte Implementierung für eine Methode bereitstellt, die bereits in ihrer übergeordneten Klasse definiert ist, spricht man von Methodenüberschreibung. Die überschriebene Methode in der Unterklasse muss dieselben Namensparameter und denselben Rückgabetyp wie die Methode in der übergeordneten Klasse haben.

Regeln für das Überschreiben von Methoden

• Namensparameter und Rückgabetyp müssen mit der übergeordneten Methode übereinstimmen.
• Java wählt die zur Laufzeit auszuführende Methode basierend auf dem tatsächlichen Objekttyp und nicht nur auf dem Referenzvariablentyp aus.
• Statische Methoden können nicht überschrieben werden.
• Der @Override-Anmerkung Erkennt Fehler wie Tippfehler in Methodennamen.

class Animal {    void move(){  System.out.println(  'Animal is moving.');     }  void eat(){    System.out.println(  'Animal is eating.');     } } class Dog extends Animal{    @Override void move(){     // move method from Base class is overriden in this  // method  System.out.println('Dog is running.');  }  void bark(){    System.out.println('Dog is barking.');     } } public class Geeks {  public static void main(String[] args)  {  Dog d = new Dog();  d.move();   d.eat();   d.bark();  } } 

Dog is running. Animal is eating. Dog is barking. 

Erläuterung: Die Animal-Klasse definiert Basisfunktionen wie bewegen() Und essen() . Die Dog-Klasse erbt von Animal und überschreibt die Methode move(), um ein bestimmtes Verhalten bereitzustellen Hund rennt. Beide Klassen können auf ihre eigenen Methoden zugreifen. Beim Erstellen eines Dog-Objekts führt der Aufruf von move() die überschriebene Methode aus.

Sonderfälle beim Überschreiben

1. Aufruf der übergeordneten Methode mit super

Der Super-Schlüsselwort kann die übergeordnete Klassenmethode von der überschreibenden Methode aus aufrufen.

class Parent{    void show(){    System.out.println('Parent's show()');  } } class Child extends Parent{    @Override  void show(){    super.show();  System.out.println('Child's show()');  } } public class Main{    public static void main(String[] args){    Parent obj = new Child();  obj.show();  } } 

Parent's show() Child's show() 

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 . 

class Parent{    // Can't be overridden  final void show(){    } } class Child extends Parent{    // This would produce error  void show() {} } 

Ausgabe :

3. Statische Methoden

• Statische Methoden können nicht überschrieben werden; Wenn Sie in einer Unterklasse eine statische Methode mit derselben Signatur wie in der Oberklasse definieren, wird die Methode der Oberklasse ausgeblendet.
• Instanzmethoden können überschrieben werden, aber eine Unterklasse kann eine statische Methode einer Oberklasse nicht überschreiben.
• Eine statische Methode in einer Unterklasse mit derselben Signatur wie eine statische Methode der Oberklasse verbirgt die ursprüngliche Methode.

class Parent{  static void staticMethod(){    System.out.println('Parent static method');  }  void instanceMethod(){    System.out.println('Parent instance method');  } } class Child extends Parent{    static void staticMethod(){    // Hides Parent's static method  System.out.println('Child static method');  }  @Override  void instanceMethod(){     // Overrides Parent's instance method  System.out.println('Child instance method');  } } public class GFG{    public static void main(String[] args){    Parent p = new Child();    // Calls Parent's static method (hiding)  p.staticMethod();    // Calls Child's overridden instance method  p.instanceMethod();   } } 

Parent static method Child instance method 

4. Private Methoden

• Private Methoden können nicht überschrieben werden, da sie für Unterklassen nicht sichtbar sind.
• Eine Unterklassenmethode mit demselben Namen wird als neue unabhängige Methode behandelt, die keinen Bezug zur übergeordneten Klasse hat.

class Parent{    private void display(){    System.out.println('Parent private method');  } } class Child extends Parent{    void display(){    // This is a new method not overriding  System.out.println('Child method');  } } public class GFG{    public static void main(String[] args){    Child c = new Child();    // Calls Child's method  c.display();   } } 

Child method 

5. Kovariante Rückgabetypen

• Beim Überschreiben von Methoden kann der Rückgabetyp der überschreibenden Methode eine Unterklasse des Rückgabetyps der überschriebenen Methode sein.
• Diese Funktion wird als kovarianter Rückgabetyp bezeichnet und ermöglicht spezifischere Rückgabetypen in der Unterklasse.

class Parent{    Parent getObject(){    System.out.println('Parent object');  return new Parent();  } } class Child extends Parent{    @Override    // Covariant return type  Child getObject() {   System.out.println('Child object');  return new Child();  } } public class GFG{    public static void main(String[] args){    Parent obj = new Child();    // Calls Child's method  obj.getObject();     } } 

Child object 

Ausnahmebehandlung beim Überschreiben

• Die überschreibende Methode kann keine neuen oder umfassenderen geprüften Ausnahmen auslösen als die Methode in der Oberklasse.
• Es können weniger oder engere geprüfte Ausnahmen ausgelöst werden.
• Es kann alle ungeprüften Ausnahmen (wie RuntimeException) unabhängig von der Superklassenmethode auslösen.

import java.io.IOException; class Parent {  void display() throws IOException {  System.out.println('Parent method');  } } class Child extends Parent {  @Override  void display() throws IOException {  System.out.println('Child method');  } } public class GFG{    public static void main(String[] args){    // Parent reference Child object  Parent obj = new Child();   try{    // Calls Child's overridden method  obj.display();   } catch (IOException e){    System.out.println('Exception caught: ' + e.getMessage());  }  } } 

Child method 

Warum verwenden wir Methodenüberschreibung?

• Um das Verhalten einer vorhandenen Methode in einer Unterklasse zu ändern oder zu verbessern.
• Um Laufzeitpolymorphismus zu erreichen, hängen Methodenaufrufe vom tatsächlichen Objekttyp ab.
• Um Methodennamen logisch wiederzuverwenden und so die Redundanz zu reduzieren.

Beispiel aus der Praxis: Mitarbeitermanagementsystem

Lassen Sie uns das Überschreiben anhand einer Analogie aus der realen Welt verstehen.

Stellen Sie sich das Mitarbeitermanagementsystem einer Organisation vor. Alle Mitarbeiter haben einige Verhaltensweisen wie raiseSalary() und promote() gemeinsam, aber die Logik unterscheidet sich für verschiedene Rollen wie Manager oder Ingenieur. Wir können ein einzelnes Employee-Array erstellen, in dem einzelne Mitarbeiter unterschiedlichen Typs sind (Vertriebstechniker usw.) und ihre Funktionen aufrufen. Dies vereinfacht den Gesamtcode erheblich.

abstract class Employee {  abstract void raiseSalary();  abstract void promote(); } class Manager extends Employee{  @Override void raiseSalary(){    System.out.println(  'Manager salary raised with incentives.');  }  @Override void promote(){    System.out.println(  'Manager promoted to Senior Manager.');  } } class Engineer extends Employee{    @Override void raiseSalary(){    System.out.println(  'Engineer salary raised with bonus.');  }  @Override void promote(){    System.out.println(  'Engineer promoted to Senior Engineer.');  } } public class Company{    public static void main(String[] args){    Employee[] employees  = { new Manager() new Engineer() };  System.out.println('--- Raising Salaries ---');  for (Employee e : employees){    e.raiseSalary();   }  System.out.println('n--- Promotions ---');  for (Employee e : employees) {  e.promote();  }  } } 

--- Raising Salaries --- Manager salary raised with incentives. Engineer salary raised with bonus. --- Promotions --- Manager promoted to Senior Manager. Engineer promoted to Senior Engineer. 

Erläuterung: Obwohl sowohl Manager- als auch Engineer-Objekte mit dem Mitarbeitertyp bezeichnet werden, ruft Java zur Laufzeit die überschriebenen Methoden der tatsächlichen Objekte auf, was den dynamischen Methodenversand (Laufzeitpolymorphismus) demonstriert.

Verwandter Artikel: Methodenüberladung und Methodenüberschreibung