Remplacer Java | Méthode redéfinissant Java | Exemples
Si une classe (sous-classe) a les mêmes méthodes que sa classe parente, elle s'appelle une Method Overriding Java . Dans la sous-classe (classe enfant), les méthodes de remplacement sont affichées avec l'annotation @override Java.
Le remplacement des méthodes est également appelé polymorphisme d'exécution en Java. Il est réalisé par un concept d'héritage d'un concept de programmation orientée objet (OOps).
Dans ce didacticiel, vous découvrirez ce qu'est le remplacement des méthodes et comment l'utiliser avec quelques exemples de base en Java.
Remplacer la syntaxe
Une syntaxe simple de Java Overriding.
class ParentClass {
//method
.....
}
class SubClass extends ParentClass{
@Override
//method
.....
}
class SubClass extends ParentClass{
@Override
//method
.....
}
Exemple de remplacement Java complet
Comment effectuer des remplacements de méthodes en Java ? Voici ci-dessous un exemple de remplacement d'une méthode employee() dans une sous-classe.
//base class
class Employee {
//method
void salary() {
System.out.println("All Employee Salary Range is 10-50k");
}
}
//subclass
class Manager extends Employee{
@Override
void salary(){
System.out.println("Manager Salary is 40k");
}
}
public class MethodOverriding {
public static void main(String arg[]){
// creating base (parent) class object
Employee employee = new Employee();
employee.salary();
// creating sub (child) class object
Employee employee1 = new Manager();
employee1.salary();
}
}
Sortie : La fourchette de salaire de tous les employés est de 10 à 50 000
Le salaire du directeur est de 40 000
Quand appliquer Override Java dans les méthodes ?
Voici un exemple complet et en temps réel de "Override Java".
Dans chaque entreprise, il y a un salaire différent selon le poste. Nous définissons donc des méthodes de salaire () qui sont remplacées. Un responsable de classe et un chef d'équipe s'étendent (héritent) dans la classe Employé.
Code :
//base class
class Employee {
//method
void salary() {
System.out.println("All Employee Salary Range is 10-50k");
}
}
//subclass
class Manager extends Employee {
@Override
void salary() {
System.out.println("Manager Salary is 40k");
}
}
//subclass
class TeamLead extends Employee {
@Override
void salary() {
System.out.println("Team Lead Salary is 30k");
}
}
public class MethodOverriding {
public static void main(String arg[]) {
// creating base (parent) class object
Employee employee = new Employee();
employee.salary();
// creating sub (child) class object
Employee employee1 = new Manager();
employee1.salary();
// creating sub (child) class object
Employee employee2 = new TeamLead();
employee2.salary();
}
}
Sortie : La fourchette de salaire de tous les employés est de 10 à 50 000
Le salaire du directeur est de 40k
Le salaire du chef d'équipe est de 30 000
Utilisation du remplacement de méthode Java
- Une déclaration spécifique des méthodes de la superclasse dans la sous-classe. Cela signifie que dans une sous-classe, vous pouvez écrire votre propre instruction (code) pour effectuer l'opération.
- Pour obtenir un polymorphisme d'exécution
Règles de remplacement de méthode Java
- La méthode de sous-classe doit avoir le même nom comme dans la classe parent.
- Méthodes remplacées parameters(argument) doit être identique aux méthodes de la classe parente.
- Requiert une relation IS-A (héritage).
- Le type de retour doit être identique à la classe parent.
- Un niveau d'accès aux méthodes ne peut pas être plus restrictif . Exemple :si la méthode de la superclasse est déclarée publique, la méthode de remplacement dans la sous-classe ne peut être ni privée ni protégée.
- Méthodes finales ne peut pas être remplacé.
- Méthodes statiques ne peut pas être remplacé mais peut être redéclaré.
- Les constructeurs ne peuvent pas être remplacés.
Pourquoi et quand un super mot-clé est-il utilisé dans le remplacement de Java ?
Réponses : Lorsque vous souhaitez utiliser une méthode de superclasse dans la sous-classe et que les mêmes méthodes sont déjà remplacées dans une sous-classe. Voici un exemple d'utilisation du super mot-clé dans le remplacement de Java.
//super class
class Office {
//method
void workHour() {
System.out.println("All Employee Work Hour is 5 to 8 Hour");
}
}
//sub class
class Manager extends Office {
@Override
void workHour() {
super.workHour();
System.out.println("Manager working for 20 hours a day");
}
}
public class MethodOverriding {
public static void main(String arg[]) {
// creating base (parent) class object
Manager manager = new Manager();
manager.workHour();
}
}
Sortie : Toutes les heures de travail des employés sont de 5 à 8 heures
Manager travaillant 20 heures par jour
Question :Quand utilisez-vous l'annotation @Override de Java et pourquoi ?
Réponses : Remplacer l'annotation Java Utilisez-la chaque fois que vous remplacez une méthode. voici que nous en mentionnons 2 raisons ou avantages.
- Ce faisant, vous pouvez profiter de la vérification par le compilateur que vos méthodes sont réellement remplacées. Vous pouvez éviter une erreur courante consistant à mal orthographier un nom de méthode ou à ne pas correspondre correctement aux paramètres. L'IDE vous montrera une erreur qui n'est pas réellement un problème de remplacement de méthode.
- Deuxièmement, cela rend votre code plus facile à comprendre, vous pouvez facilement trouver que cette méthode est remplacée.
Question :Est-ce que le remplacement du constructeur en Java est possible ?
Réponses : Non, le remplacement du constructeur n'est pas possible car la JVM appellera le constructeur de la superclasse lors de la création de l'instance de la classe enfant.
Chaque fois qu'une instance de sous-classe est créée, le constructeur de la classe de base est appelé. Continuez ensuite avec les instructions du constructeur de sous-classe.
Les constructeurs Java ne sont pas des méthodes qui peuvent être remplacées.
Question : Pouvez-vous remplacer la méthode principale Java ?
Réponses : Non, vous ne pouvez pas remplacer la méthode principale en Java car il s'agit d'une méthode statique.
Question :Pourquoi Java n'est-il pas autorisé à remplacer les méthodes statiques ?
Réponses : Les méthodes Java statiques sont traitées comme globales par la JVM, elles ne sont pas du tout liées à une instance d'objet.
Question :Pouvez-vous remplacer une méthode statique ?
Réponses : Non, une méthode statique ne peut pas être remplacée en Java. Parce que Overriding est un exemple de polymorphisme d'exécution.
Faites un commentaire si vous avez des doutes et des suggestions ci-dessous.
