Java @Override

L'annotation @Override est utilisée lorsqu'un développeur remplace une fonction en Java pour utiliser le même nom de fonction mais attribue à ces fonctions des propriétés différentes. Si vous êtes conscient des fonctions over Rise en Java mais que vous n'avez pas utilisé l'annotation @override car vous n'aviez pas envie de l'utiliser comme option obligatoire pour l'écrire explicitement. Il est activé par défaut depuis l'introduction de Java 1.5. Il favorise le polymorphisme au moment de l’exécution. En effet, nous pouvons remplacer n'importe quelle fonction sans utiliser d'annotation. Néanmoins, il présente un avantage majeur : si le compilateur, par hasard, manque le remplacement (comme si le développeur avait fait une faute d'orthographe dans le nom de la fonction de remplacement). À l'aide de l'annotation de remplacement, le compilateur comprendra et remplacera la fonction de base par la fonction enfant. Il améliore également la lisibilité du code, réduisant ainsi le temps et les efforts de maintenance.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Syntaxe :

public @interface Override

Le signe « @ » doit être présent avant de remplacer le mot-clé pour que le compilateur comprenne s'il s'agit d'une annotation ou non. La fonction de remplacement doit avoir la même définition avec le type de retour et un certain nombre de paramètres dans les classes de base et héritées. S'il y a une différence entre l'un de ces éléments, elle ne sera pas considérée comme une fonction de remplacement tout en comprenant cette fonction comme une nouvelle fonction.

Comment fonctionne @Override Annotation en Java ?

• L'annotation de remplacement est utilisée juste avant la fonction de remplacement définie dans la classe héritée pour garantir que le compilateur comprend que cette fonction est intentionnellement définie avec les mêmes paramètres et le même type de retour dans deux classes différentes.
• Pour que le système comprenne quelle fonction appeler car la fonction a les mêmes paramètres dans la classe de base et la classe héritée, nous devons appeler la fonction à l'aide d'instances.
• Si une fonction est appelée en utilisant l'objet d'une classe parent, alors la fonction de la classe parent avec sa définition de fonction locale est appelée tandis que si l'objet d'une classe héritée est utilisé, alors la fonction d'une classe héritée est invoquée.

Exemple :

Base class {}
Child class{}
Base object1= new Base();// Here Base class is instantiated so the function definition will be called from base class.
Base object2= new Child(); /// Here Child class is instantiated so the
function definition will be called from child class

• Maintenant, les objets définis ci-dessus nommés « objet1 » et « objet2 » sont utilisés avec l'opérateur point pour extraire la définition de la fonction.
• Toutes ces fonctions ne fonctionnent que si elles sont maintenues sous la classe principale à partir de laquelle commence l'exécution réelle du code.
• Le contrôle frappera la classe principale puis recherchera les instances d'objet des classes prédéfinies au-dessus de la classe principale.
• L'objet invoquera alors la fonction appelée.
• On peut également transmettre les paramètres souhaités dans la fonction s'ils sont déjà définis dans la définition de classe en tant que prototype.
• Une classe de base peut être héritée par plusieurs classes ; la seule différence réside dans la création d'objet et l'appel de fonction à l'aide de cet objet.

Exemples de Java @Override

Vous trouverez ci-dessous les exemples :

Exemple n°1

Un exemple pour démontrer le fonctionnement de l'annotation de remplacement.

Explication :

Il y a deux classes définies dans le programme ci-dessous : l'une est la classe de base, qui est également appelée classe parent « Pclass », tandis que l'autre classe « Cclass » qui hérite des propriétés et des fonctions membres de la base, est appelée classe héritée ou classe enfant. La fonction est tout d'abord déclarée dans la classe parent. Dans cet exemple, le nom de la fonction est printfunction() à qui est assigné le travail d'impression de la chaîne passée en paramètre.

Une fonction du même nom est déclarée et définie dans une classe héritée appelée « Cclass » avec l'annotation @override la précédant. Une autre chaîne lui est passée en paramètre. Dans la classe principale, les classes définies ci-dessus sont instanciées en créant leurs objets. « object1 » identifie l'objet de Pclass et « object2 » identifie l'objet de Cclass. La même fonction est appelée en utilisant ces différents objets. Dans le premier cas, object1 récupère la chaîne de Pclass, qui est la classe parent. Plus tard, lorsque object2 est appelé, l'annotation @override entre en action et modifie la chaîne de contenu. Il s'agit d'une fonctionnalité primordiale fournie sous Java pour un code compréhensible et de meilleures fonctionnalités.

Code :

// This is Base class
class Pclass {
void printfunction()
{
System.out.println("This is the output of function present in parent class \"Pclass\". ");
}
}
// This is Child class
class Cclass extends Pclass {
// The below function is override function along with override annotation
@Override
void printfunction()
{
System.out.println("This is the output of function present in child class \"Cclass\".");
}
}
// Thi is Main class from here the contro; execution starts. JAVA compiler searches for main class to start executing any code.
public class Main {
public static void main(String[] args)
{
Pclass object1 = new Pclass();
object1.printfunction();
Pclass object2 = new Cclass();
object2.printfunction();
}
}

Sortie :

Voici l'écran de sortie avec deux lignes de chaîne. La première ligne de chaîne provient de la fonction de base, tandis que la deuxième ligne de chaîne provient de la fonction de substitution définie dans la classe héritée.

Example #2

Here we have one base class with two child classes inheriting it. The second inherited class is instantiated, and the output string is triggered from the 2^nd inherited class.

Code:

class Pclass {
void printfunction()
{
System.out.println("This is the output of function present in parent class \"Pclass\". ");
}
}
// This is Child class
class Cclass extends Pclass {
// The below function is override function along with override annotation
@Override
void printfunction()
{
System.out.println("This is the output of function present in child class \"Cclass\".");
}
}
// This is Child class
class Cclass2 extends Pclass {
// The below function is override function along with override annotation
@Override
void printfunction()
{
System.out.println("This is the output of function present in child class number 2 \"Cclass\".");
}
}
// This is Main class from here the contro; execution starts. JAVA compiler searches for main class to start executing any code.
public class Main {
public static void main(String[] args)
{
Pclass object1 = new Pclass();
object1.printfunction();
Pclass object2 = new Cclass2();
object2.printfunction();
}
}

Output:

Conclusion

Hence Java override function comes with a lot of benefits like providing run-time polymorphism, easy code access, clean code and many more. Adding override annotation assures that the compiler understands the intention of function definition via function declarations in classes. This is one of the important properties of the oops concept called polymorphism.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!