Remplacement en Java
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 (); } }
Sortir
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.
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 (); } }
Sortir
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 .
Java class Parent { // Can't be overridden final void show (){ } } class Child extends Parent { // This would produce error void show () {} }
Sortir :
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 (); } }
Sortir
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 (); } }
Sortir
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 (); } }
Sortir
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 ()); } } }
Sortir
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.
Java 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 (); } } }
Sortir
--- 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
