När en underklass tillhandahåller en specifik implementering för en metod som redan är definierad i sin överordnad klass kallas den metod som överskrider. Den åsidosatta metoden i underklassen måste ha samma namnparametrar och returtyp som metoden i överordnad klass.

Regler för metodöverträdelse

• Namnparametrar och returtyp måste matcha överordnadsmetoden.
• Java väljer vilken metod som ska köras vid körning baserat på den faktiska objekttypen, inte bara referensvariabeltypen.
• Statiska metoder kan inte åsidosättas.
• De @Override -kommentar fångar misstag som typfel i metodnamn.

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. 

Förklaring: Djurklassen definierar basfunktioner som flytta() och äta() . Hundklassen ärver från djur och åsidosättande Metoden () för att ge ett specifikt beteende Hunden är igång. Båda klasserna kan komma åt sina egna metoder. När du skapar ett hundobjektsamtal () kör den åsidosatta metoden.

Särskilda fall i övergripande

1. Ringande överordnad metod med super

De supernyckelord kan åberopa överordnad klassmetod från den övergripande metoden.

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.  Slutliga metoder kan inte åsidosättas

Om vi ​​inte vill att en metod ska åsidosättas förklarar vi det som  slutlig . Se  Använda slutlig med arv . 

rad och kolumn

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

Produktion :

3. Statiska metoder

• Statiska metoder kan inte åsidosättas; Att definiera en statisk metod i en underklass med samma signatur som i superklassen gömmer Superclass -metoden.
• Instansmetoder kan åsidosättas men en underklass kan inte åsidosätta en statisk metod för superklass.
• En statisk metod i en underklass med samma signatur som en Superclass -statisk metod döljer den ursprungliga metoden.

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. Privata metoder

• Privata metoder kan inte åsidosättas eftersom de inte är synliga för underklasser.
• En underklassmetod med samma namn behandlas som en ny oberoende metod som inte är relaterad till överordnad klass.

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. Kovariant returtyper

• I metod som åsidosätter returtypen för den övergripande metoden kan vara en underklass av returtypen för den åsidosatta metoden.
• Denna funktion är känd som kovariant returtyp och tillåter mer specifika returtyper i underklassen.

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 

Undantagshantering i övergripande

• Den övergripande metoden kan inte kasta nya eller bredare kontrollerade undantag än metoden i superklassen.
• Det kan kasta färre eller smalare kontrollerade undantag.
• Det kan kasta eventuella okontrollerade undantag (som RuntimeException) oavsett Superclass -metoden.

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 

Varför använder vi metodöverskridande?

• För att ändra eller förbättra beteendet hos en befintlig metod i en underklass.
• För att uppnå runtime -polymorfism - Metodsamtal beror på den faktiska objekttypen.
• För att återanvända metodnamn Logiskt minskar redundansen.

Exempel på verkligt liv: Anställdas ledningssystem

Låt oss förstå överskridande med en verklig analogi.

Föreställ dig en organisations anställdas ledningssystem. Alla anställda delar vissa beteenden som höjning () och marknadsför () men logiken skiljer sig åt olika roller som chef eller ingenjör. Vi kan skapa en enda anställdsuppsättning där enskilda anställda är av olika typer (försäljningsteknik etc) och kalla deras funktioner. Detta förenklar den övergripande koden mycket.

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. 

Förklaring: Även om både chef och ingenjörsobjekt hänvisas till att använda Java med anställdstyp kallar de åsidosatta metoderna för de faktiska objekten vid körning som visar dynamisk metodsändning (runtime -polymorfism).

Relaterad artikel: Metodöverbelastning och metodöverskridande