Fonction virtuelle en Java

Étant un langage de programmation orienté objet, Java prend en charge des fonctionnalités telles que l'héritage, le polymorphisme, la conversion ascendante, etc. Par conséquent, les POO en Java traitent des objets, des classes et des fonctions. Une fonction virtuelle est l’une des fonctions membres qui facilitent le polymorphisme d’exécution en Java. Dans cet article, nous discuterons de la fonction virtuelle en Java.

Définition : Une fonction virtuelle n'est pas une fonction spéciale, mais c'est une fonction membre qui facilite le mécanisme de substitution de méthode. Cela signifie que dans les POO, une fonction virtuelle de la classe parent est une fonction qui peut être remplacée par une classe enfant qui a le même type mais avec des fonctionnalités différentes.

PUBLICITÉ Cours populaire dans cette catégorie MAÎTRISÉE JAVA - Spécialisation | 78 séries de cours | 15 tests simulés

Commencez votre cours de développement de logiciels libres

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

Syntaxe : Pour la fonction virtuelle en Java, vous devez suivre la syntaxe de base de Java avec des annotations. Pour implémenter le mécanisme de remplacement de la fonction virtuelle, l'annotation @Override peut être utilisée ici pour indiquer spécifiquement quelle fonction virtuelle nous voulons remplacer, bien que ce ne soit pas obligatoire.

Comment fonctionne la fonction virtuelle en Java ?

Voyons maintenant comment fonctionne la fonction virtuelle. Lorsque nous appelons une méthode surchargée d'une classe enfant via sa référence de type parent, alors le type ou la référence de l'objet indique quelle méthode sera invoquée. La conclusion de cette décision a lieu pendant l'exécution après la compilation. Ainsi, la fonctionnalité de la fonction virtuelle est remplacée par la classe enfant héritée du même type.

Quelques points concernant la fonction virtuelle :

• Les fonctions des classes enfant et parent doivent avoir le même nom et avoir le même paramètre.
• La relation IS-A est obligatoire (héritage).
• Une fonction virtuelle ne peut pas être privée car nous ne pouvons pas remplacer les méthodes privées de la classe parent.
• Une fonction virtuelle ne peut pas être déclarée comme Final, car nous ne pouvons pas remplacer les méthodes Final.
• Une fonction virtuelle ne peut pas être déclarée comme statique, car nous ne pouvons pas remplacer les méthodes statiques.

Exemples de fonctions virtuelles en Java

Nous discuterons ici de quelques exemples de code de fonction virtuelle.

Exemple n°1

Dans cet exemple, nous allons montrer comment la fonction virtuelle showMe() affiche un texte différent selon la référence d'objet à laquelle elle est associée. Lorsqu'il est associé au type « Head », il affiche les messages de la classe parent. Lorsqu'il est associé au type « Subordonné », il affiche les messages de la classe enfant.

Code :

class Head {
public void showMe() {
System.out.println("I am Head");
}
}
class Subordinate extends Head {
@Override
public void showMe() {
System.out.println("I am Subordinate ");
}
}
public class VirtualFuntionDemo {
public static void main(String args[]) {
Head superObject = new Head();
superObject.showMe(); //method of super class or parent class is called
Head subObject = new Subordinate(); // upcasting
subObject.showMe();//method of sub class or child class is called by Parent reference, this is called "Virtual function"
Subordinate subObject2 = new Subordinate();
subObject2.showMe(); //method of sub class or child class is called
}
}

Sortie :

Exemple n°2

Prenons un exemple de fonction virtuelle dans le cas d'un héritage multiniveau. Dans cet exemple, nous prenons en compte deux niveaux d’héritage. Dans cet exemple, nous allons montrer comment la fonction virtuelle administration() affiche différents messages selon le type d'objet auquel elle est associée. Lorsqu'il est associé au type « State », il affiche les messages de la classe parent. Lorsqu'il est associé au type « District », il affiche les messages de sa classe enfant. Toujours au deuxième niveau d'héritage, lorsqu'il est associé au type « Municipalité », il affiche les messages de sa classe enfant de son parent, la classe « District ».

Code :

class State{
void administartion() {
System.out.println("This is under state govt.");
}
}
class District extends State{
void administartion(){
System.out.println("This is under District Magistrate");
}
}
class Municipality extends District{
void administartion(){
System.out.println("This is under Mayor ");
}
}
public class VirtualFunctionDemo2 {
public static void main(String args[]){
State superObject=new State ();
State subObject=new District ();
State sub2Object=new Municipality ();
superObject. administartion ();
subObject.administartion (); // run time polymorphism occurs in virtual function happening in first level of heritance
sub2Object.administartion (); // run time polymorphism occurs in virtual function happening in 2nd level of heritance
}
}

Sortie :

Exemple #3

Prenons un autre exemple de polymorphisme d'exécution dans le cas d'un héritage multiniveau. Dans cet exemple, trois niveaux d'héritage sont pris en compte. Dans cet exemple, nous allons montrer comment la fonction virtuelle whoami() affiche différentes fonctionnalités selon le type d'objet auquel elle est associée. Lorsqu'il est associé au type « Cars », il affiche les messages de la classe parent. Lorsqu'il est associé au type « SUV », il affiche les messages de sa classe enfant. Toujours au deuxième niveau d'héritage, lorsqu'il est associé au type « MPV », il affiche les messages de sa classe enfant de sa classe parent, la classe « SUV ». Toujours au troisième niveau d'héritage, lorsqu'il est associé au type « Hatchback », il affiche les messages de sa classe enfant de son parent, la classe « MPV ».

Code :

class Cars{
void whoami() {
System.out.println("This is Car");
}
}
class SUV extends Cars{
void whoami(){
System.out.println("This is SUV");
}
}
class MPV extends SUV{
void whoami(){
System.out.println("This is MPV");
}
}
class Hatchback extends MPV{
void whoami(){
System.out.println("This is hatchback");
}
}
public class VirtualFunctionDemo3 {
public static void main(String args[]){
Cars superObject=new Cars();
Cars subObject=new SUV();  // object of child type : 1st level heritance
Cars sub2Object=new MPV();  // object of child type : 2nd level heritance
Cars sub3Object=new Hatchback();  // object of child type : 3rd level heritance
superObject.whoami();
subObject.whoami();  //run time polymorphism occurs in virtual function happening in first level of heritance
sub2Object.whoami(); //run time polymorphism occurs in virtual function  happening in second level of heritance
sub3Object.whoami(); //run time polymorphism occurs in virtual function  happening in third level of heritance
}
}

Sortie :

Conclusion

Ceci conclut notre apprentissage du sujet « Fonction virtuelle en Java ». Écrivez-vous les codes mentionnés dans les exemples ci-dessus dans le compilateur Java et vérifiez le résultat. L'apprentissage des codes sera incomplet si vous n'écrivez pas le code par vous-même.

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!