C # virtuel

Une fonction virtuelle en C # peut être remplacée dans les sous-classes. Une fonction virtuelle en C # a à la fois une implémentation de classe parent et enfant. Chaque fois que la fonctionnalité principale d'une méthode est presque la même, cependant, la sous-classe nécessite une capacité supplémentaire, et elle est utilisée. La phrase virtuelle est utilisée pour définir une fonction virtuelle dans la superclasse, qui est ensuite remplacée par la phrase de remplacement dans la sous-classe. Chaque fois qu'une fonction est spécifiée comme une fonction virtuelle dans une superclasse, la sous-classe peut choisir de l'emporter ou non. La méthodologie primordiale permet à une fonction d'avoir de nombreuses formes. En conséquence, c'est une bonne illustration du polymorphisme. Commençons par utiliser certains des exemples C # pour élaborer le fonctionnement du mot-clé «virtuel» pour créer et utiliser les fonctions virtuelles dans le code. Nous devons créer un fichier C # dans lequel nous pouvons ajouter le code des fonctions virtuelles avec la requête «Touch» comme ci-dessous.

Exemple # 01

Commençons par l'exemple le plus élémentaire d'utiliser la méthode virtuelle en C #. Nous utiliserons la bibliothèque système dans notre code dans la première ligne en utilisant le mot-clé «Utilisation» comme affiché. Après cela, nous avons créé une classe de base publique nommée «Parent» en utilisant le mot-clé «classe». Cette classe de base contient une fonction unique nommée «Show» du type de retour void et du modificateur d'accès public, i.e., fonction virtuelle.

Cette fonction virtuelle contient une instruction de fonction writeLine () de la classe de console pour imprimer la phrase textuelle simple lors de l'exécution sur notre écran, je.e., «Méthode virtuelle dans la classe parent». Une autre classe publique nommée «Child» a été créée après cela. Comme indiqué, cette classe a été dérivée de la classe «parent». La méthode «Show» a été mise en œuvre en son sein qui a été remplacée par la classe de base «parent» en utilisant le mot-clé «remplacer» suivi du type de retour «void» et a commencé avec le modificateur d'accès «public».

Comme cette fonction virtuelle a été remplacée par la classe de base, elle doit contenir une implémentation supplémentaire. Ainsi, nous utilisons ici l'instruction écrite () de la classe de console pour afficher une nouvelle chaîne de texte sur le shell indiquant la «méthode virtuelle primordiale dans la classe enfant». Les fonctions de classe parent et d'enfants sont du même nom mais une implémentation un peu différente. Toute cette implémentation fonctionnera après avoir utilisé la méthode principale () dans le code. Nous avons donc créé une nouvelle classe indépendante nommée «New» avec le mot-clé «classe». Cette classe contient une méthode Main () de type statique avec un type de retour vide. L'exécution a commencé par la création d'un objet de classe parent «O1» avec le mot-clé «nouveau» suivi du nom de classe. Nous avons utilisé ce nouvel objet O1 pour appeler la fonction virtuelle «Show» de la classe parent. Après cela, nous avons créé un autre objet O2 pour la classe d'enfants en utilisant le mot-clé «nouveau», en commençant par le nom de la classe de base et en se terminant par le nom de la classe d'enfants. Cela montre que l'héritage réel a eu lieu dans le code C #. L'objet de classe d'enfants «O2» a été utilisé pour appeler la fonction virtuelle «Show» remplacée de la classe enfant. L'appel de fonction ne doit pas être mélangé lors de l'exécution de la méthode principale (). De plus, nous devons obtenir la fonction show () de la classe parent exécutée d'abord, puis la fonction show () de la fonction de classe infantile. La classe nouvelle s'est terminée ici, et notre code est terminé maintenant.

Après avoir enregistré ce code au sein de l'éditeur de texte, nous sommes retournés au terminal car notre code doit être compilé avec le compilateur «MCS» C #. Après la compilation réussie, nous avons essayé l'exécution de son fichier «EXE» qui vient d'être créé dans le dossier à domicile avec l'exécution «mono» de C #. Il a exécuté le code et affiché la chaîne de la méthode virtuelle à partir de la classe parent d'abord, puis le texte de la chaîne de la méthode Show () Overrid () de la classe enfant.

Exemple # 02

Faisons notre code un peu avancé et différent de l'exemple ci-dessus. Nous l'avons commencé avec l'utilisation de la bibliothèque système dans la première ligne de code. Après cela, nous avons utilisé un test de noms de classe globale contenant trois autres classes et une fonction Main (). La première classe, «Rectangle», est une classe parentale des deux autres classes. Nous avons déclaré 3 variables publiques de double type «H», «W» et «R» avec 10, 4 et 3, respectivement. Une variable constante à double type «P» a été déclarée avec une valeur «PI» intégrée des mathématiques. Une méthode virtuelle «Area ()» du type de double retour a été définie ici qui a renvoyé le résultat de la multiplication de «H» et «W» à la fonction principale () de la classe de test, i.e., La zone d'un rectangle est, la hauteur se multiplier par largeur. La classe «carrée» a été dérivée de la classe «rectangle». Cette classe remplace la fonction virtuelle «zone» de sa classe de base et renvoie le résultat de la multiplication de «h» et «h», i.e., La zone d'un carré est un côté multiplié par le deuxième côté ou la hauteur en hauteur.

Ensuite, nous avons un «cercle» de classe dérivée en remplacement de la fonction virtuelle «zone» du rectangle de classe de base. Cette fonction renvoie le résultat de la multiplication de «p» et «r * r», i.e., La zone d'un cercle est «pi» multipliée par le carré d'un rayon. Trois classes ont été définies et implémentées dans le code entièrement. Maintenant, c'est le tour du tour de la fonction principale de C # pour démarrer son exécution et exécuter progressivement les classes. Dans la méthode Main () de la classe de test, nous avons créé un objet «O1» du rectangle de classe parent à la première ligne en utilisant le nom d'une classe avec le «nouveau» mot-clé.

En utilisant la classe rectangle, nous avons créé des objets O2 et O3 pour les classes dérivées carré et cercle, respectivement. Trois déclarations WriteLine () de la classe de console ont été utilisées ici pour afficher respectivement la zone du rectangle, du carré et du cercle. Pour calculer la zone pour trois formes, nous avons utilisé les objets respectifs de chaque classe de forme. Ces objets ont appelé leurs fonctions virtuelles respectives définies dans la classe rectangle et remplacées dans les classes dérivées, i.e., Carré et cercle.

Il est temps de compiler ce code C # nouvellement créé dans le shell avec l'instruction de commande «MCS». Après cela, utilisez l'instruction d'exécution mono pour exécuter le fichier «exe» qui a été généré à la suite de la compilation. Lors de l'exécution de ce fichier «exe» pour le code, nous avons la zone de rectangle, carré et cercle affichée sur notre écran car nous avons utilisé la fonction virtuelle dans une classe et l'avoir remplacée dans les classes dérivées.

Conclusion

Nous avons décrit comment une simple fonction virtuelle C # peut être utilisée dans le code C # et remplacée dans ses sous-classes. Nous avons démontré son travail dans cet article avec l'aide de quelques exemples. Le premier exemple a illustré l'utilisation de la fonction virtuelle dans le programme d'héritage unique, tandis que le deuxième exemple démontre qu'avec l'aide de plusieurs héritages. C'est ainsi que nous avons montré comment une méthode simple peut être utilisée pour effectuer plusieurs calculs avec la définition unique d'une fonction en C #.