Lorsqu'une sous-classe fournit une implémentation spécifique pour une méthode déjà définie dans sa classe parent, cela est appelé remplacement de méthode. La méthode substituée dans la sous-classe doit avoir les mêmes paramètres de nom et le même type de retour que la méthode de la classe parent.

Règles de remplacement de méthode

• Les paramètres de nom et le type de retour doivent correspondre à la méthode parent.
• Java sélectionne la méthode à exécuter au moment de l'exécution en fonction du type d'objet réel et pas seulement du type de variable de référence.
• Les méthodes statiques ne peuvent pas être remplacées.
• Le @Remplacer l'annotation détecte les erreurs comme les fautes de frappe dans les noms de méthodes.

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. 

Explication: La classe Animal définit des fonctionnalités de base comme se déplacer() et manger() . La classe Dog hérite de Animal et remplacements la méthode move() pour fournir un comportement spécifique Le chien court. Les deux classes peuvent accéder à leurs propres méthodes. Lors de la création d'un objet Dog, l'appel de move() exécute la méthode remplacée.

Cas particuliers de dérogation

1. Appel de la méthode parent à l'aide de super

Le super mot-clé peut invoquer la méthode de la classe parent à partir de la méthode de remplacement.

chaîne n 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.  Les méthodes finales ne peuvent pas être remplacées

Si nous ne voulons pas qu'une méthode soit surchargée, nous la déclarons comme  final . S'il vous plaît voir  Utiliser Final avec héritage . 

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

Sortir :

si sinon boucle en java

3. Méthodes statiques

• Les méthodes statiques ne peuvent pas être remplacées ; définir une méthode statique dans une sous-classe avec la même signature que dans la superclasse masque la méthode de la superclasse.
• Les méthodes d'instance peuvent être remplacées, mais une sous-classe ne peut pas remplacer une méthode statique de superclasse.
• Une méthode statique dans une sous-classe avec la même signature qu’une méthode statique de superclasse masque la méthode d’origine.

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éthodes privées

• Les méthodes privées ne peuvent pas être remplacées car elles ne sont pas visibles par les sous-classes.
• Une méthode de sous-classe portant le même nom est traitée comme une nouvelle méthode indépendante sans rapport avec la classe parent.

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. Types de retour covariants

• Dans le remplacement de méthode, le type de retour de la méthode de remplacement peut être une sous-classe du type de retour de la méthode remplacée.
• Cette fonctionnalité est connue sous le nom de type de retour covariant et permet des types de retour plus spécifiques dans la sous-classe.

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 

Gestion des exceptions lors du remplacement

• La méthode de substitution ne peut pas lancer d'exceptions vérifiées nouvelles ou plus larges que la méthode de la superclasse.
• Il peut générer des exceptions vérifiées moins nombreuses ou plus étroites.
• Il peut lever toutes les exceptions non vérifiées (comme RuntimeException) quelle que soit la méthode 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 

Pourquoi utilisons-nous le remplacement de méthode ?

• Pour modifier ou améliorer le comportement d'une méthode existante dans une sous-classe.
• Pour obtenir le polymorphisme d'exécution, les appels de méthode dépendent du type d'objet réel.
• Réutiliser les noms de méthodes en réduisant logiquement la redondance.

Exemple concret : système de gestion des employés

Comprenons la substitution avec une analogie du monde réel.

Imaginez le système de gestion des employés d’une organisation. Tous les employés partagent certains comportements comme raiseSalary() et Promouvoir() mais la logique diffère selon les rôles comme Manager ou Ingénieur. Nous pouvons créer un tableau d'employés unique dans lequel les employés individuels sont de différents types (technologie de vente, etc.) et appeler leurs fonctions. Cela simplifie beaucoup le code 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. 

Explication: Bien que les objets Manager et Engineer soient tous deux référencés à l'aide du type Employee, Java appelle les méthodes remplacées des objets réels au moment de l'exécution, démontrant la répartition dynamique des méthodes (polymorphisme d'exécution).

Article connexe : Surcharge de méthode et remplacement de méthode

sélectionner plusieurs tables SQL