Når en underklasse gir en spesifikk implementering for en metode som allerede er definert i foreldreklassen, kalles det metode som er overstyrt. Den overstyrte metoden i underklassen må ha samme navnparametere og returtype som metode i overordnet klasse.

Regler for overstyring av metoden

• Navnparametere og returtype må samsvare med overordnet metode.
• Java plukker ut hvilken metode som skal kjøres på kjøretid basert på den faktiske objekttypen, ikke bare referansevariabel -typen.
• Statiske metoder kan ikke overstyres.
• De @Override merknad Fanger feil som skrivefeil i metodenavn.

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 basefunksjonaliteter som flytte() og spise() . Hundeklassen arver fra dyr og overstyrer MOVE () -metoden for å gi en spesifikk oppførsel Hunden løper. Begge klasser kan få tilgang til sine egne metoder. Når du oppretter et hundeobjekt som ringer Move (), utfører den overstyrte metoden.

Spesielle saker i overstyring

1. Ringer foreldremetode ved hjelp av super

De Super nøkkelord kan påkalle foreldreklassemetoden fra den overordnede 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.  Endelige metoder kan ikke overstyres

Hvis vi ikke vil at en metode skal overstyres, erklærer vi den som  Endelig . Se  Bruker finale med arv . 

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

Produksjon :

3. Statiske metoder

• Statiske metoder kan ikke overstyres; Å definere en statisk metode i en underklasse med samme signatur som i superklassen skjuler superklasse -metoden.
• Forekomstmetoder kan overstyres, men en underklasse kan ikke overstyre en statisk metode for superklasse.
• En statisk metode i en underklasse med samme signatur som en superklasse statisk metode skjuler den opprinnelige 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. Private metoder

• Private metoder kan ikke overstyres fordi de ikke er synlige for underklasser.
• En underklasse -metode med samme navn blir behandlet som en ny uavhengig metode som ikke er relatert til foreldreklassen.

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 returtyper

• I metoden som overstyrer returtypen til den overordnede metoden kan være en underklasse av returtypen til den overstyrte metoden.
• Denne funksjonen er kjent som Covariant returtype og tillater mer spesifikke 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 

Unntakhåndtering i overstyring

• Den overordnede metoden kan ikke kaste nye eller bredere sjekket unntak enn metoden i superklassen.
• Det kan kaste færre eller smalere sjekket unntak.
• Det kan kaste eventuelle ukontrollerte unntak (som RuntimeException) uavhengig av superklasse -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 bruker vi metoden overstyring?

• Å endre eller forbedre oppførselen til en eksisterende metode i en underklasse.
• For å oppnå runtime -polymorfisme - Metodesamtaler avhenger av den faktiske objekttypen.
• For å gjenbruke metodenavn, reduserer logisk redundans logisk.

Eksempel på det virkelige liv: Ansattes styringssystem

La oss forstå overstyring med en virkelig analogi.

Se for deg en organisasjons ansattes styringssystem. Alle ansatte deler litt atferd som Raisesalary () og promoterer (), men logikken er forskjellig for forskjellige roller som manager eller ingeniør. Vi kan opprette en enkelt ansattes matrise der individuelle ansatte er av forskjellige typer (salgsteknologi osv.) Og kaller funksjonene deres. Dette forenkler den samlede koden mye.

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: Selv om både manager- og ingeniørobjekter blir referert til ved bruk av ansattes type, kaller Java de overstyrte metodene for de faktiske objektene ved runtime som demonstrerer dynamisk metode utsendelse (runtime polymorfisme).

Relatert artikkel: Metode overbelastning og metode overordnede