Atunci când o subclasă oferă o implementare specifică pentru o metodă care este deja definită în clasa sa părinte, se numește metodă de suprasolicitare. Metoda suprasolicitată din subclasă trebuie să aibă aceleași parametri de nume și tipul de retur ca metoda din clasa părinte.

Reguli pentru Metoda Supravegherea

• Parametrii de nume și tipul de retur trebuie să se potrivească cu metoda părinte.
• Java alege ce metodă să ruleze la timpul de rulare pe baza tipului de obiect real nu doar a tipului de variabilă de referință.
• Metodele statice nu pot fi anulate.
• @Adnotare care se află Prinde greșeli precum dactilografiile în numele metodelor.

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. 

Explicaţie: Clasa de animale definește funcționalitățile de bază precum mişcare() şi mânca() . Clasa de câini moștenește de la animal și Înlocuire Metoda Move () pentru a oferi un comportament specific Câinele aleargă. Ambele clase pot accesa propriile metode. Când creați un obiect de câine care apelează la Move () execută metoda suprasolicitată.

blocați reclamele youtube pe Android

Cazuri speciale în supraveghere

1. Calling Metoda părinte folosind Super

cuvânt super -cheie Poate invoca metoda clasei părinte din metoda de suprapunere.

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.  Metodele finale nu pot fi anulate

Dacă nu dorim ca o metodă să fie anulată, o declarăm ca  final . Vă rugăm să consultați  Folosirea finală cu moștenire . 

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

Ieșire :

3. Metode statice

• Metodele statice nu pot fi anulate; Definirea unei metode statice într -o subclasă cu aceeași semnătură ca în superclasa ascunde metoda superclasa.
• Metodele de instanță pot fi anulate, dar o subclasă nu poate înlocui o metodă statică Superclass.
• O metodă statică dintr -o subclasă cu aceeași semnătură ca o metodă statică Superclass ascunde metoda inițială.

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. Metode private

• Metodele private nu pot fi anulate, deoarece nu sunt vizibile subclaselor.
• O metodă de subclasă cu același nume este tratată ca o nouă metodă independentă care nu are legătură cu clasa părinte.

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. Tipuri de întoarcere covariante

• În metoda care depășește tipul de retur al metodei de suprasolicitare poate fi o subclasă a tipului de retur al metodei suprasedtate.
• Această caracteristică este cunoscută sub numele de tip de retur covariant și permite tipuri de retur mai specifice în subclasă.

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 

Excepție de gestionare a suprasolicitării

• Metoda de suprasolicitare nu poate arunca excepții noi sau mai largi verificate decât metoda din superclasa.
• Poate arunca excepții verificate mai puține sau mai restrânse.
• Poate arunca orice excepții necontrolate (cum ar fi RuntimeException), indiferent de metoda Superclass.

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 

De ce folosim metoda suprasolicitată?

• Să schimbe sau să îmbunătățească comportamentul unei metode existente într -o subclasă.
• Pentru a realiza polimorfismul de rulare - apelurile metodei depind de tipul de obiect real.
• Pentru a reutiliza numele metodelor reducând logic redundanța.

Exemplu din viața reală: Sistem de management al angajaților

Să înțelegem suprapunerea cu o analogie din lumea reală.

controlul programului stocat

Imaginează -ți sistemul de gestionare a angajaților unei organizații. Toți angajații împărtășesc unele comportamente precum RISEISALARY () și promovează (), dar logica diferă pentru diferite roluri precum manager sau inginer. Putem crea un singur tablou de angajați în care angajații individuali sunt de diferite tipuri (tehnologie de vânzări etc.) și să le apelăm la funcțiile. Acest lucru simplifică foarte mult codul general.

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. 

Explicaţie: Deși atât obiectele de manager, cât și de inginer sunt menționate utilizând tipul de angajat Java apelează la metodele suprasolicitate ale obiectelor reale la runtime, demonstrând dispecerea metodei dinamice (polimorfismul de rulare).

Articol înrudit: Supraîncărcarea metodei și metoda suprasolicită

java matematică pow