Comment utiliser le polymorphisme en C #
Table des matières
- Qu'est-ce que le polymorphisme en C #
- Types de polymorphisme en C #
- Surcharge de méthode
- Méthode remplacée
- Exemples de polymorphisme en C #
- Comment utiliser le polymorphisme en C #
- Conclusion
Qu'est-ce que le polymorphisme en C #
Le polymorphisme vient de deux mots grecs: poly et se transformer. Le mot poly ici représente beaucoup, et se transformer représente les formulaires. C'est la capacité de l'objet à programmer à acquérir différentes formes.
Le polymorphisme permet de traiter des objets de classes distinctes comme ils provenaient de la même classe. Cela peut être fait en utilisant le concept d'héritage, car il permet aux classes dérivées de prendre ou hériter des propriétés de la classe de base.
Types de polymorphisme en C #
Le polymorphisme peut être classé en deux types en fonction du moment où il se produit:
- Temps de compilation [surcharge de méthode]
- Runtime [méthode dominante]
Surcharge de méthode
La surcharge de méthode peut définir plusieurs méthodes ayant le même nom mais contenant des paramètres différents. Le compilateur décide de la méthode qui sera appelée sur la base des arguments donnés à la méthode. En utilisant la surcharge de méthode, nous pouvons effectuer des tâches similaires mais qui ont des paramètres d'entrée différents.
Méthode remplacée
Méthode remplacée en C # est une technique qui permet à une classe dérivée de fournir sa propre implémentation d'une méthode déjà fournie par sa classe de base. La méthode remplacée est exactement comme la fonction virtuelle de C++. Lorsqu'une méthode dans une classe dérivée a le même nom, le même type de retour et les mêmes paramètres qu'une méthode dans sa classe de base, alors la méthode de la classe dérivée est censée remplacer la méthode dans la classe de base.
Dans le polymorphisme, la méthode de base remplacée doit être virtuelle, abstraite ou remplacement. Les méthodes de remplacement mettent en œuvre les membres de la classe de base existants d'une manière nouvelle. La méthode remplacée est réalisée en utilisant les mots clés virtuels et remplacés.
Exemples de polymorphisme en C #
Ci-dessous, un exemple de code qui explique les deux méthodes remplacant et surchargez en C #:
Exemple 1: surcharge de méthode
Ici, dans l'exemple ci-dessous, nous avons défini plusieurs méthodes en une seule classe. Toutes ces méthodes partagent le même nom mais contiennent des paramètres différents.
Utilisation du système;programme de classe
void Calculedum (int num1, int num2)
Console.WriteLine ($ "La somme de num1 et num2 est num1 + num2");
void Calculateum (double num1, double num2)
Console.WriteLine ($ "La somme de num1 et num2 est num1 + num2");
statique void main (String [] args)
Program Program = nouveau programme ();
int intnum1 = 1;
int intnum2 = 2;
Double Doublenum1 = 12.5;
Double Doublenum2 = 7.5;
programme.Calculateum (intnum1, intnum2);
programme.Calculateum (Doublenum1, Doublenum2);
Le code ci-dessus donne deux nombres à résumer, et il démontre Surcharge de méthode en C #. Le Calcul La méthode est surchargée pour accepter deux paramètres entiers et deux doubles paramètres, respectivement.
La méthode principale crée une instance de la classe de programme et appelle deux fois la méthode Calculateum, une fois avec deux arguments entiers et une fois avec deux doubles arguments.
Lorsque le programme s'exécute, il imprime la somme des deux nombres transmis au Calcul Méthode utilisant l'interpolation de chaîne pour créer le message de sortie. La sortie suivante peut être vue sur la console:
Exemple 2: Méthode Overriding
Cet exemple démontre le concept de mise à niveau de la méthode, où une classe dérivée peut fournir sa propre implémentation d'une méthode héritée de sa classe de base.
Utilisation du système;forme de classe publique
Draw Void virtuel () public ()
Console.WriteLine ("Drawing a Shape");
Rectangle de classe publique: forme
Public Override Void Draw ()
Console.WriteLine ("Drawing a Rectangle");
programme de classe publique
public static void main (String [] args)
Forme de forme = nouvelle forme ();
forme.Dessiner();
Rectangle rectangle = new rectangle ();
rectangle.Dessiner();
Voici une classe de base qui est nommée Classe de forme. La classe de forme contient une méthode virtuelle appelée Dessiner. Ici, un mot-clé virtuel est une indication qu'une classe dérivée peut remplacer la méthode définie.
La classe rectangle remplace le Dessiner méthode et est dérivé de la classe de forme. La classe rectangulaire a son propre ensemble de propriétés pour la mise en œuvre. Dans ce cas, la méthode de dessin de la classe rectangle imprime Dessiner un rectangle au lieu de Dessiner une forme.
Ensuite, dans Principal(), Une instance de la classe de forme est créée, et sa méthode de dessin est appelée. Alors une instance de la classe rectangle est créée, et sa méthode de dessin est appelée.
Parce que la classe rectangle remplace la méthode de dessin de la classe de forme, lorsque nous appelons la méthode de dessin sur l'objet rectangle, l'implémentation de la classe rectangle est appelée, et Dessiner un rectangle est imprimé sur la console. Lorsque le programme s'exécutera, il sortira:
Comment utiliser le polymorphisme en C #
Après avoir connu le concept de polymorphisme en C #, nous allons maintenant couvrir les étapes pour l'utiliser en programmation C #.
Étape 1: Définissez la classe de base
La première étape consiste à définir la classe de base qui contient les méthodes ou les propriétés qui seront partagées par toutes les classes dérivées. La classe de base est définie à l'aide du classe mot-clé:
animal de classe publiqueMADION VOID VIDURE PUBLIQUE ()
Console.Writeline ("L'animal fait un son");
Le code ci-dessus contient une classe de base Animal qui a une méthode virtuelle Faites du bruit. Le mot-clé virtuel montre que la classe dérivée remplacera la méthode définie.
Étape 2: Définissez les classes dérivées
L'étape suivante consiste à définir les classes dérivées qui proviennent de la classe de base. En C #, nous pouvons définir une classe dérivée en utilisant le ":" opérateur.
chien de classe publique: animalPublic Override Void Makeound ()
Console.Writeline ("The Dog Barks");
Chat de classe publique: animal
Public Override Void Makeound ()
Console.Writeline ("The Cat Meows");
L'exemple ci-dessus contient deux classes de lecteur Chien et Chat, Et ces deux classes prennent des propriétés de la classe de base qui s'appelle Animal. Les deux classes remplacent le Faites du bruit Méthode avec leur implémentation.
Étape 3: Utilisez le polymorphisme
La dernière étape consiste à utiliser le polymorphisme dans le code. Nous allons maintenant définir les instances des classes dérivées et appeler leurs méthodes en utilisant la référence de la classe de base.
Animal myanimal = nouvel animal ();Animal MyDog = nouveau chien ();
Animal mycat = new cat ();
Myanimal.Faites du bruit();
mon chien.Faites du bruit();
mon chat.Faites du bruit();
Ici, nous avons créé des instances de cours d'animaux, de chiens et de chats. Après cela, le Faites du bruit la méthode est appelée sur chaque instance. Depuis le Faites du bruit La méthode est virtuelle, l'implémentation réelle qui est appelée dépend du type réel de l'instance. Cela signifie que lorsque nous appelons MyDog.Makeound () ou mycat.Makeound (), le Faites du bruit la méthode sera appelée en classe de chien ou de chat, respectivement.
Exemple de code
Voici le code combiné des étapes ci-dessus:
Utilisation du système;animal de classe publique
MADION VOID VIDURE PUBLIQUE ()
Console.Writeline ("L'animal fait un son");
chien de classe publique: animal
Public Override Void Makeound ()
Console.Writeline ("The Dog Barks");
Chat de classe publique: animal
Public Override Void Makeound ()
Console.Writeline ("The Cat Meows");
programme de classe publique
public static void main ()
Animal myanimal = nouvel animal ();
Animal MyDog = nouveau chien ();
Animal mycat = new cat ();
Myanimal.Faites du bruit();
mon chien.Faites du bruit();
mon chat.Faites du bruit();
Après avoir exécuté le code ci-dessus, la sortie suivante peut être vue sur la console:
Conclusion
L'utilisation du polymorphisme dans C # un code peut être écrite qui gère plusieurs types d'objets. En C #, nous pouvons utiliser le polymorphisme en définissant une classe de base, en créant des classes dérivées qui héritent de la classe de base et en utilisant la référence de la classe de base pour appeler les méthodes des classes dérivées. En suivant les étapes décrites dans l'article ci-dessus, n'importe qui peut utiliser le concept de polymorphisme en C #.