Kun alaluokka tarjoaa erityisen toteutuksen menetelmään, joka on jo määritelty emoluokassaan, sitä kutsutaan menetelmän ohittamiseksi. Alaluokan ohitetulla menetelmällä on oltava samat nimiparametrit ja palautustyyppi kuin menetelmällä emoluokassa.

Menetelmän ohittamista koskevat säännöt

• Nimiparametrien ja palautustyypin on vastattava vanhemman menetelmää.
• Java poimii, minkä menetelmän suoritettavana ajon aikana todellisen objektityypin perusteella ei vain referenssimuuttujatyyppiä.
• Staattisia menetelmiä ei voida ohittaa.
• Se @Override -merkintä Saat virheet, kuten kirjoitusvirheet menetelmänimissä.

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. 

Selitys: Eläinluokka määrittelee perusfunktionaalisuudet, kuten liikkua() ja syödä() . Koiran luokka perii eläimeltä ja ohittaa siirto () -menetelmä tietyn käyttäytymisen aikaansaamiseksi Koira on käynnissä. Molemmat luokat voivat käyttää omia menetelmiään. Kun luodaan koiran objekti, Soittaminen liikkuu () suorittaa ohitetun menetelmän.

Erikoistapaukset

1. Soittaminen vanhempien menetelmään superkäyttöön

Se super -avainsana voi vedota emoluokan menetelmään ohitusmenetelmästä.

ero pythonissa

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.  Lopullisia menetelmiä ei voida ohittaa

Jos emme halua menetelmän ohittamista, ilmoitamme sen  lopullinen . Katso  Finaalilla perinnön kanssa . 

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

Tulos -

3. Staattiset menetelmät

• Staattisia menetelmiä ei voida ohittaa; Staattisen menetelmän määritteleminen alaluokassa, jolla on sama allekirjoitus kuin superluokkaan, piilottaa superluokan menetelmän.
• Esimerkkimenetelmät voidaan ohittaa, mutta alaluokka ei voi ohittaa superluokan staattista menetelmää.
• Staattinen menetelmä alaluokassa, jolla on sama allekirjoitus kuin superluokan staattinen menetelmä, piilottaa alkuperäisen menetelmän.

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. Yksityiset menetelmät

• Yksityisiä menetelmiä ei voida ohittaa, koska ne eivät ole näkyvissä alaluokille.
• Alaluokkamenetelmää, jolla on sama nimi, käsitellään uutena riippumattomana menetelmänä, joka ei liity emoluokkaan.

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. Kovariantin paluutyypit

• Menetelmässä, joka ohittaa ohitusmenetelmän paluutyypin, voi olla ohitetun menetelmän palautustyypin alaluokka.
• Tämä ominaisuus tunnetaan kovarianttina paluutyypiksi ja sallii alaluokan tarkempia paluutyyppejä.

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 

Poikkeuskäsittely ylenmääräisesti

• Yleinen menetelmä ei voi heittää uusia tai laajempia tarkistettuja poikkeuksia kuin superluokan menetelmä.
• Se voi heittää vähemmän tai kapeampia tarkistettuja poikkeuksia.
• Se voi heittää mahdolliset valvontaa (kuten RuntimeException) superluokan menetelmästä riippumatta.

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 

Miksi käytämme menetelmän ohittamista?

• Alaluokkaan olemassa olevan menetelmän käyttäytymisen muuttaminen tai parantaminen alaluokassa.
• Runtime -polymorfismin saavuttamiseksi - menetelmäkutsut riippuvat todellisesta objektityypistä.
• Menetelmän nimien uudelleenkäyttö vähentäen loogisesti redundanssia.

Tosielämän esimerkki: Työntekijöiden hallintajärjestelmä

Ymmärretään, että ylenmääräiset analogialla.

c Boolen arvo

Kuvittele organisaation työntekijöiden hallintajärjestelmä. Kaikilla työntekijöillä on joitain käyttäytymismalleja, kuten RaiseSalary () ja edistää (), mutta logiikka eroaa eri rooleista, kuten johtaja tai insinööri. Voimme luoda yhden työntekijän taulukon, jossa yksittäiset työntekijät ovat erityyppisiä (myyntitekniikka jne.) Ja soittaa heidän toimintoihinsa. Tämä yksinkertaistaa kokonaiskoodia paljon.

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. 

Selitys: Vaikka sekä johtaja- että insinööri -objekteihin viitataan työntekijän tyypin käyttämiseen, Java kutsuu todellisten objektien ohitettuja menetelmiä suorituksen aikana osoittaen dynaamisen menetelmän lähetyksen (ajonaikainen polymorfismi).

Aiheeseen liittyvä artikkeli: Menetelmän ylikuormitus ja menetelmän ohittaminen