Introduction au mot-clé virtuel en C #
Quel est le mot-clé virtuel? Avant de passer directement à la perspective C #, il est important de comprendre ou de réviser le concept d'héritage, de mot-clé prioritaire et virtuel dans le monde de la programmation orientée objet.
La substitution de méthode est un concept de POO étroitement lié à l'héritage. Lorsqu'une méthode de classe enfant remplace la méthode de classe parente du même nom, paramètres et type de retour, elle est appelée substitution de méthode. Un mot-clé virtuel indique au compilateur qu'une méthode peut être remplacée dans des classes dérivées.
En ce qui concerne la perspective C #, le mot-clé virtuel est utilisé pour modifier la déclaration de toute propriété, méthode ou événement pour permettre la substitution dans une classe dérivée. En termes simples, le mot-clé virtuel implémente le concept de substitution de méthode en C #.
Syntaxe
Toute propriété, méthode ou événement peut être remplacé en ajoutant le mot-clé virtuel dans la classe de base et le mot-clé override dans la classe dérivée.
Ajoutez le mot-clé virtuel dans la déclaration de classe de base:
public class Base (
public virtual int abc ( get; set; ) // this property can be overridden
public virtual void Xyz() ( ) // this method can be overridden
)
Ajoutez le mot clé override dans la déclaration de classe de base:
public class Derived : Base (
public override int abc ( get; set; ) // this overrides the base class property
public override void Xyz() ( ) // this overrides the base class method
)
Comment fonctionne Virtual en C #?
La différence très fondamentale entre la surcharge et la surcharge est que le premier est un mécanisme de compilation, tandis que le second entre en jeu au moment de l'exécution. Un mot-clé virtuel entre en action au moment de l'exécution, mettant ainsi en œuvre le concept de substitution de méthode.
Lorsqu'une méthode ou une propriété virtuelle est invoquée ou accessible, le compilateur recherche un membre prioritaire de la méthode ou de la propriété. S'il en trouve un, il est invoqué. Si aucun n'est trouvé, la méthode ou la propriété d'origine est invoquée.
Une excellente question se pose ici - que se passe-t-il en cas d'héritage à plusieurs niveaux? Eh bien, si un membre de classe est remplacé à plusieurs niveaux, le membre remplacé le plus profond est appelé (celui de la classe la plus dérivée).
Exemple
L'exemple suivant de mot-clé virtuel en C # est mentionné ci-dessous
Héritage à un niveau
Prenons un exemple pour comprendre le fonctionnement d'un mot-clé virtuel lorsqu'une seule classe enfant hérite de la classe parent, c'est-à-dire qu'il n'y a pas d'héritage à plusieurs niveaux.
using System;
public class Polynomial
(
public virtual double len
(
get;
set;
)
public virtual double wid
(
get;
set;
)
public virtual double Area()
(
return len * wid;
)
)
public class Rectangle: Polynomial
(
)
public class Square : Polynomial
(
public override double len
(
get;
set;
)
public override double Area()
(
return len * len;
)
)
public class Circle : Polynomial
(
public double radius
(
get;
set;
)
public override double Area()
(
return Math.PI * radius * radius;
)
)
public class Triangle : Polynomial
(
public override double Area()
(
return 0.5 * len * wid;
)
)
public class Program
(
public static void Main()
(
var rect = new Rectangle();
rect.len = 5;
rect.wid = 10;
Console.WriteLine("Area of Rectangle = " + rect.Area());
var sq = new Square();
sq.len = 15;
Console.WriteLine("Area of Square = " + sq.Area());
var cir = new Circle();
cir.radius = 10;
Console.WriteLine("Area of Circle = " + cir.Area());
var tri = new Triangle();
tri.len = 5;
tri.wid = 10;
Console.WriteLine("Area of Triangle = " + tri.Area());
)
)
Comment fonctionne le code ci-dessus?
Dans la classe de base Polynomial, nous avons déclaré deux propriétés et une méthode comme virtuelles. Celles-ci peuvent désormais être remplacées dans les classes enfants. Nous créons maintenant différentes classes enfants de formes différentes héritant de la classe Polynomiale.
Dans la classe Rectangle, nous n'avons pas besoin de remplacer une propriété ou une méthode. L'implémentation de la classe de base fonctionnerait telle quelle pour la classe Rectangle.
Dans la classe Square, nous n'avons pas la propriété width. Nous remplaçons donc la propriété length et la méthode Area pour renvoyer le carré de la longueur.
Dans la classe Circle, nous n'avons ni longueur ni largeur. Ainsi, nous déclarons une nouvelle propriété de rayon spécifique à la classe et remplaçons la méthode Area en conséquence.
Dans la classe Triangle, nous remplaçons simplement la méthode Area et les propriétés sont héritées de la classe de base Polynomial.
Lorsque nous créons des objets des classes dérivées, le compilateur rencontre le mot-clé virtuel lors de la construction de la classe de base et recherche ainsi les membres remplacés. Les membres remplacés sont ensuite appelés en conséquence.
Héritage à plusieurs niveaux
Modifions l'exemple ci-dessus pour inclure l'héritage à plusieurs niveaux.
using System;
public class Polynomial
(
public virtual double len ( get; set; )
public virtual double wid ( get; set; )
public virtual double Area()
( return 0; )
)
public class Rectangle : Polynomial
(
public override double Area()
( return len * wid; )
)
public class Square : Rectangle
(
public override double len ( get; set; )
public override double Area()
( return len * len; )
)
public class Program
(
public static void Main()
(
var rect = new Rectangle();
rect.len = 5;
rect.wid = 10;
Console.WriteLine("Area of Rectangle = " + rect.Area());
var sq = new Square();
sq.len = 15;
Console.WriteLine("Area of Square = " + sq.Area());
)
)
Les avantages
Un membre virtuel a des déclarations et des définitions dans la classe de base et les classes dérivées. Les membres virtuels sont avantageux lorsque certaines fonctionnalités supplémentaires sont requises dans les classes dérivées. Ils servent d'add-ons.
Règles
- Une variable ne peut pas être déclarée virtuelle. Seuls les propriétés, méthodes et événements peuvent être déclarés virtuels.
- Un membre statique ne peut pas être déclaré virtuel.
- Un membre abstrait ne peut pas être déclaré virtuel.
- Un membre privé ne peut pas être déclaré virtuel.
- Un membre non virtuel ne peut pas être remplacé.
- Le niveau d'accès, le type et le nom des membres virtuels et des membres prioritaires doivent être identiques. Par exemple, si la méthode virtuelle est publique, la méthode prioritaire doit également être publique.
Conclusion - Mot-clé virtuel en C #
Dans cet article, nous avons compris le concept de virtuel en C #. Nous avons vu comment C # implémente le mot-clé virtuel pendant l'exécution et regardé les exemples.
Les membres virtuels sont un excellent concept de programmation orientée objet. Cependant, pour acquérir des connaissances approfondies, il est fortement recommandé de se renseigner sur les mots clés abstraits, les interfaces et les nouveaux mots clés. Cela aiderait grandement à comprendre la différence entre tous. Cela aide à comprendre quand utiliser et quand ne pas utiliser le virtuel.
Articles recommandés
Ceci est un guide des mots-clés virtuels en C #. Nous discutons ici du fonctionnement de Virtual en C # et de la façon dont le code ci-dessus fonctionne avec l'héritage et les avantages à plusieurs niveaux. Vous pouvez également consulter l'article suivant pour en savoir plus-
- Copier le constructeur en C #
- Héritage en C #
- Fonctions C #
- Instruction C # if
- Instruction If en Python
- Surcharge en Java
- Surcharge Python
- Héritage en PHP
- Guide complet de l'héritage en Python
- Types de constructeur en C # avec implémentation de code