Wanneer een subklasse een specifieke implementatie biedt voor een methode die al is gedefinieerd in de bovenliggende klasse, wordt dit methodeoverschrijving genoemd. De overschreven methode in de subklasse moet dezelfde naamparameters en hetzelfde retourtype hebben als de methode in de bovenliggende klasse.

Regels voor het overschrijven van methoden

• Naamparameters en retourtype moeten overeenkomen met de bovenliggende methode.
• Java kiest welke methode tijdens runtime moet worden uitgevoerd op basis van het daadwerkelijke objecttype en niet alleen van het type referentievariabele.
• Statische methoden kunnen niet worden overschreven.
• De @Annotatie overschrijven vangt fouten zoals typefouten op in methodenamen.

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. 

Uitleg: De klasse Animal definieert basisfunctionaliteiten zoals beweging() En eten() . De klasse Dog erft van Animal en overschrijft de move() methode om specifiek gedrag te bieden Hond rent. Beide klassen hebben toegang tot hun eigen methoden. Bij het maken van een Dog-object dat move() aanroept, wordt de overschreven methode uitgevoerd.

willekeurig, niet in Java

Speciale gevallen bij overschrijven

1. Oudermethode bellen met behulp van super

De supertrefwoord kan de bovenliggende klassemethode aanroepen vanuit de overschrijvende methode.

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.  Definitieve methoden kunnen niet worden overschreven

Als we niet willen dat een methode wordt overschreven, declareren we deze als  definitief . Zie alstublieft  Finale gebruiken met erfenis . 

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

Uitvoer :

3. Statische methoden

• Statische methoden kunnen niet worden overschreven; het definiëren van een statische methode in een subklasse met dezelfde signatuur als in de superklasse verbergt de superklassemethode.
• Instantiemethoden kunnen worden overschreven, maar een subklasse kan een statische superklassemethode niet overschrijven.
• Een statische methode in een subklasse met dezelfde signatuur als een statische methode van een superklasse verbergt de oorspronkelijke 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. Privémethoden

• Privémethoden kunnen niet worden overschreven omdat ze niet zichtbaar zijn voor subklassen.
• Een subklassemethode met dezelfde naam wordt behandeld als een nieuwe onafhankelijke methode die geen verband houdt met de bovenliggende klasse.

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. Covariante retourtypen

• Bij het overschrijven van een methode kan het retourtype van de overschrijvende methode een subklasse zijn van het retourtype van de overschreven methode.
• Deze functie staat bekend als covariant retourtype en maakt meer specifieke retourtypen in de subklasse mogelijk.

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 

Afhandeling van uitzonderingen bij overschrijven

• De overschrijvende methode kan geen nieuwe of breder gecontroleerde uitzonderingen genereren dan de methode in de superklasse.
• Het kan minder of smaller gecontroleerde uitzonderingen opleveren.
• Het kan alle niet-gecontroleerde uitzonderingen genereren (zoals RuntimeException), ongeacht de superklassemethode.

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 

Waarom gebruiken we methodeoverschrijving?

• Om het gedrag van een bestaande methode in een subklasse te veranderen of te verbeteren.
• Om runtime-polymorfisme te bereiken, zijn methodeaanroepen afhankelijk van het daadwerkelijke objecttype.
• Om methodenamen te hergebruiken, waardoor redundantie logischerwijs wordt verminderd.

Voorbeeld uit de praktijk: werknemersbeheersysteem

Laten we het overschrijven begrijpen met een analogie uit de echte wereld.

Stel je het werknemersbeheersysteem van een organisatie voor. Alle werknemers delen bepaalde gedragingen, zoals raiseSalary() en promote(), maar de logica verschilt voor verschillende rollen, zoals Manager of Engineer. We kunnen een enkele werknemersarray maken waarin individuele werknemers van verschillende typen zijn (verkooptechnologie, enz.) en hun functies aanroepen. Dit vereenvoudigt de algehele code aanzienlijk.

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. 

Uitleg: Hoewel er naar zowel Manager- als Engineer-objecten wordt verwezen met het type Werknemer, roept Java de overschreven methoden van de werkelijke objecten tijdens runtime aan, wat de dynamische methodeverzending demonstreert (runtime polymorfisme).

Gerelateerd artikel: Methode-overbelasting en methode-overschrijving