Quan una subclasse proporciona una implementació específica per a un mètode que ja està definit a la seva classe de pares, s’anomena mètode. El mètode anul·lat de la subclasse ha de tenir els mateixos paràmetres de nom i el tipus de retorn que el mètode de la classe pare.

Normes per a la superació del mètode

• Paràmetres de nom i tipus de retorn han de coincidir amb el mètode pare.
• Java tria quin mètode funcionarà en temps d'execució en funció del tipus d'objecte real, no només el tipus de variable de referència.
• Els mètodes estàtics no es poden anul·lar.
• El Annotació @Override Captura errors com els tipografies en noms de mètodes.

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. 

Explicació: La classe d’animals defineix les funcionalitats de base com moure () i menjar () . La classe de gossos hereta de l’animal i anul·lar el mètode Move () per proporcionar un comportament específic El gos corre. Les dues classes poden accedir als seus propis mètodes. Quan es crea un objecte de gos que truca a Move () Executa el mètode anul·lat.

Casos especials per sobrepassar

1. Truqueu al mètode dels pares mitjançant Super

El Paraula súper clau Pot invocar el mètode de la classe de pares a partir del mètode de la superació.

concat cadenes java

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.  Els mètodes finals no es poden anul·lar

Si no volem que es substitueixi un mètode, ho declarem com  final . Si us plau, consulteu  Utilitzant final amb herència . 

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

Producció :

3. Mètodes estàtics

• Els mètodes estàtics no es poden anul·lar; Definir un mètode estàtic en una subclasse amb la mateixa signatura que a la superclasse amaga el mètode de la superclasse.
• Els mètodes d’instància es poden anul·lar, però una subclasse no pot substituir un mètode estàtic de la superclasse.
• Un mètode estàtic en una subclasse amb la mateixa signatura que un mètode estàtic de la superclasse amaga el mètode original.

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. Mètodes privats

• Els mètodes privats no es poden anul·lar perquè no són visibles per a les subclasses.
• Un mètode de subclasse amb el mateix nom es tracta com un nou mètode independent sense relació amb la classe de pares.

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. Tipus de retorn covariant

• En el mètode Superació del tipus de retorn del mètode de sobretensió pot ser una subclasse del tipus de retorn del mètode anul·lat.
• Aquesta característica es coneix com a tipus de retorn Covariant i permet tipus de retorn més específics a la subclasse.

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 

Manipulació d'excepcions en excés

• El mètode de sobrecàrrega no pot llançar excepcions noves o més àmplies que el mètode de la superclasse.
• Pot llançar menys o més estretes excepcions.
• Pot llançar qualsevol excepció no controlada (com RunTimeException) independentment del mètode de la superclasse.

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 

Per què utilitzem el mètode de sobredimensionament?

• Per canviar o millorar el comportament d’un mètode existent en una subclasse.
• Per aconseguir el polimorfisme de temps d'execució, les trucades de mètodes depenen del tipus d'objecte real.
• Per reutilitzar els noms de mètodes reduint lògicament la redundància.

Exemple de la vida real: sistema de gestió dels empleats

Entenem que la superació amb una analogia del món real.

java i swing

Imagineu -vos el sistema de gestió d’empleats d’una organització. Tots els empleats comparteixen alguns comportaments com RaisesaLary () i promocionen (), però la lògica difereix per a diferents rols com el gestor o l’enginyer. Podem crear una sola matriu d’empleats on els empleats individuals siguin de diferents tipus (tecnologia de vendes, etc.) i anomenar les seves funcions. Això simplifica molt el codi global.

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. 

Explicació: Tot i que tant els objectes de gestor com d’enginyers es fan referència a l’ús del tipus d’empleat, java truca els mètodes anul·lats dels objectes reals en temps d’execució que demostren un despatx de mètodes dinàmics (polimorfisme d’execució).

Article relacionat: Mètode sobrecàrrega i substitució del mètode