Når en underklasse tilvejebringer en specifik implementering for en metode, der allerede er defineret i sin overordnede klasse, kaldes den metode tilsidesættende. Den tilsidesættede metode i underklassen skal have samme navnparametre og returtype som metoden i overordnede klassen.

Regler for metode tilsidesættelse

• Navnparametre og returtype skal matche overordnet metode.
• Java vælger hvilken metode der skal køres på køretid baseret på den faktiske objekttype ikke kun referencevariabeltypen.
• Statiske metoder kan ikke tilsidesættes.
• De @Override annotation Fanger fejl som skrivefejl i metodenavne.

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. 

Forklaring: Dyreklassen definerer basisfunktionaliteter som flytte() og spise() . Hundeklassen arver fra dyr og tilsidesætter Metoden til flytning () til at give en bestemt opførsel Hund kører. Begge klasser kan få adgang til deres egne metoder. Når du opretter et hundeobjekt, der kalder Move () udfører den tilsidesættede metode.

Særlige sager i tilsidesættelse

1. kalder forældremetode ved hjælp af Super

De Super nøgleord kan påkalde overordnet klassemetode fra den altoverskyggende metode.

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.  Endelige metoder kan ikke tilsidesættes

Hvis vi ikke ønsker, at en metode skal tilsidesættes, erklærer vi den som  endelig . Se venligst  Brug af finalen med arv . 

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

Produktion :

3. statiske metoder

• Statiske metoder kan ikke tilsidesættes; Definition af en statisk metode i en underklasse med samme signatur som i superklassen skjuler superklasse -metoden.
• Forekomstmetoder kan tilsidesættes, men en underklasse kan ikke tilsidesætte en superklasse statisk metode.
• En statisk metode i en underklasse med samme signatur som en statisk superklasse skjuler den originale metode.

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 metoder

• Private metoder kan ikke tilsidesættes, fordi de ikke er synlige for underklasser.
• En underklasse -metode med samme navn behandles som en ny uafhængig metode, der ikke er relateret til forældreklassen.

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 metoden kan tilsidesættelse af returtypen af ​​den altoverskyggende metode være en underklasse af returtypen for den tilsidesættede metode.
• Denne funktion er kendt som covariant returtype og tillader mere specifikke 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 

Undtagelseshåndtering i tilsidesættelse

• Den overordnede metode kan ikke kaste nye eller bredere kontrollerede undtagelser end metoden i superklassen.
• Det kan kaste færre eller smalere kontrollerede undtagelser.
• Det kan kaste eventuelle ukontrollerede undtagelser (som RuntimeException) uanset 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 

Hvorfor bruger vi metode tilsidesættende?

• At ændre eller forbedre opførslen af ​​en eksisterende metode i en underklasse.
• For at opnå runtime -polymorfisme - metodeopkald afhænger af den faktiske objekttype.
• For at genbruge metodenavne, der logisk reducerer redundans.

Eksempel på det virkelige liv: Medarbejderstyringssystem

Lad os forstå at overtræde med en reel analogi.

Forestil dig en organisations medarbejderstyringssystem. Alle medarbejdere deler nogle opførsler som Raisesalary () og fremmer (), men logikken adskiller sig for forskellige roller som manager eller ingeniør. Vi kan oprette en enkelt medarbejderarray, hvor individuelle medarbejdere er af forskellige typer (salgsteknologi osv.) Og kalder deres funktioner. Dette forenkler den samlede kode meget.

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. 

Forklaring: Selvom både manager- og ingeniørobjekter henvises til at bruge medarbejdertypen Java kalder de tilsidesatte metoder til de faktiske objekter ved runtime, der viser dynamisk metodeafsendelse (runtime -polymorfisme).

Relateret artikel: Metodeoverbelastning og metode tilsidesætter