Introduction au polymorphisme en C #
Le polymorphisme est l'un des principes de la programmation orientée objet. Poly signifie multiple et morphing signifie subir une transformation, le polymorphisme signifie donc la capacité de prendre des formes multiples.
La sortie des opérateurs varie en fonction des types d'opérandes, qui est une forme de polymorphisme connue sous le nom de surcharge d'opérateur. Ici, l'opérateur peut prendre plusieurs formes pour produire différentes sorties. La sortie des fonctions varie en fonction de différents types et paramètres de retour, qui est une autre forme de polymorphisme connue sous le nom de surcharge de fonction. Ici, la fonction prend plusieurs formes pour produire plusieurs sorties.
Le polymorphisme est largement utilisé pour implémenter l'héritage. Les objets qui ont une structure interne différente peuvent implémenter une interface commune par polymorphisme. Le diagramme suivant illustre le fonctionnement du polymorphisme:
Cette figure explique que l'argile est l'objet parent à partir duquel des objets en pot, bol et jouet sont fabriqués. Tous ces objets sont différents les uns des autres mais ils ont les propriétés de l'argile. Ces trois objets ont des formes différentes et sont utilisés de différentes manières même lorsqu'ils sont fabriqués à partir du même matériau d'argile.
Formes de polymorphisme
Voici les 2 formes de polymorphisme:
1. Surcharge de l'opérateur
Un opérateur peut donner différentes sorties en fonction du type d'opérandes sur lequel il opère. C'est ce qu'on appelle la surcharge de l'opérateur. Par exemple, l'opérateur '+' peut effectuer l'addition sur deux entiers, alors qu'il peut concaténer deux chaînes. Ainsi, le même opérateur peut être utilisé de 2 manières différentes. L'opérateur d'addition ajoute généralement deux nombres. Cependant, dans le cas de nombres complexes, l'addition est un peu différente, où les parties réelles et imaginaires correspondantes sont ajoutées séparément. Voici un exemple de code qui montre comment l'opérateur '+' peut être surchargé pour ajouter des nombres complexes:
Code:
using System;
namespace Overload (
class Complex
(
public double x;
public double y;
// no-argument constructor
public Complex() ()
// parameterized constructor
public Complex(double real, double img)
(
x = real;
y = img;
)
// Overloading of Binary "+" operator
public static Complex operator + (Complex c1,
Complex c2)
(
Complex c3 = new Complex();
c3.x = c1.x + c2.x;
c3.y = c1.y + c2.y;
return c3;
)
// function to display result
public void display()
(
Console.WriteLine("(0) + (1)i", x, y);
)
)
class CalNum (
// Driver Code
static void Main(string() args)
(
Complex num1 = new Complex(2.5, 3.5);
Complex num2 = new Complex(1.2, 6.5);
Complex num3 = num1 + num2;
Console.Write("c1 = ");
num1.display();
Console.Write("c2 = ");
num2.display();
Console.Write("c3 = ");
num3.display();
)
)
)
Production:
Cette sortie illustre la surcharge de l'opérateur pour ajouter deux nombres complexes. Le code montre la surcharge de l'opérateur ainsi que la surcharge de fonction.
2. Surcharge de fonction
Une fonction peut donner différentes sorties en fonction du nombre de paramètres ainsi que de leurs types de retour et du type de retour de fonction. Le code mentionné ci-dessus couvre également la surcharge de fonctions à l'aide d'un constructeur. Il y a 2 constructeurs dans le code; l'un est le constructeur par défaut qui est laissé vide tandis que l'autre est un constructeur paramétré qui est utilisé pour initialiser le nombre complexe avec les valeurs mentionnées comme paramètres.
En prenant l'exemple illustré sur la figure, la fonction est de mouler l'argile et la direction de course est l'élément prévu pour mouler l'argile. Sur la base de différentes directions de course, l'argile se transforme respectivement en pot, bol et jouet.
Code:
using System;
using System.Collections.Generic;
public class Clay
(
// A few example members
public int Height ( get; set; )
public int strokeDirection ( get; set; )
// Virtual method
public virtual void Mould()
(
Console.WriteLine("Beginning to mould the clay");
)
)
class Pot : Clay
(
public override void Mould()
(
// Code to make a pot Console.WriteLine("Making a pot");
base.Mould();
)
)
class Bowl : Clay
(
public override void Mould()
(
// Code to make a bowl
Console.WriteLine("Making a bowl");
base.Mould();
)
)
class Toy : Clay
(
public override void Mould()
(
// Code to make a toy
Console.WriteLine("Making a toy");
base.Mould();
)
)
class Program
(
static void Main(string() args)
(
// Illustrating Polymorphism #1: a Pot, Bowl and Toy
// can all be used wherever Clay is expected. No cast is
// needed because an implicit conversion exists from a derived
// class to its base class.
var items = new List
(
new Pot(),
new Bowl(),
new Toy()
);
// Polymorphism at work #2: the virtual method Mould is
// invoked on each of the derived classes, not the base class.
foreach (var item in items)
(
item.Mould();
)
)
)
Production:
Comme vous l'avez peut-être noté dans le code, la classe d'argile est la classe parent dont les classes enfants sont des classes de pot, de jouet et de bol. La méthode 'Mold' est définie dans la classe parent ainsi que dans la classe enfant avec la même signature de fonction. Par conséquent, lorsqu'un objet de la classe enfant est créé et qu'il appelle la méthode Mold, la méthode de classe de base est remplacée par la méthode de classe enfant. Ainsi, nous voyons la sortie de la méthode de classe enfant. Le code ci-dessus montre une méthode remplaçant et non surchargeant pour illustrer le polymorphisme.
Points à garder à l'esprit pour le polymorphisme en c #
- La surcharge est différente de la surcharge. La surcharge a différentes signatures de fonction tandis que la surcharge a les mêmes signatures de fonction
- Le polymorphisme fait référence au changement du comportement d'une superclasse dans la sous-classe.
- L'héritage fait référence à l'utilisation de la structure et du comportement d'une superclasse dans une sous-classe.
Voici les quelques points clés à retenir:
- Le polymorphisme est l'un des paradigmes majeurs de la programmation orientée objet.
- La surcharge de fonction modifie la fonction selon les types de retour et les paramètres de la fonction dans la classe héritée.
- La surcharge de l'opérateur modifie la définition de l'opérateur selon les paramètres donnés.
- Le polymorphisme est utilisé pour l'implémenter, il décide au moment de l'exécution d'appeler la méthode de classe enfant à l'aide de la substitution de méthode.
Articles recommandés
Ceci est un guide sur le polymorphisme en C #. Nous discutons ici des deux formes de polymorphisme en C #, c'est-à-dire la surcharge d'opérateur et la surcharge de fonction avec un exemple de code. Vous pouvez également consulter l'article suivant pour en savoir plus -
- Qu'est-ce que StringBuilder en C #
- Copier le constructeur en C #
- Qu'est-ce que le multithreading en C #?
- Qu'est-ce que Design Pattern en C #?
- Types de constructeur en C # avec implémentation de code
- Guide complet du multithreading en C #