Polymorphisme en C#

Le polymorphisme est un concept réalisé dans les langages de programmation orientés objet comme C#, où un opérateur ou une méthode fonctionnelle peut prendre plusieurs formes tout au long du processus d'exécution. Il est largement utilisé pour la mise en œuvre de l'héritage dans le programme, et celui-ci est classé en deux méthodes, à savoir la surcharge d'opérateurs et la surcharge de fonctions. En termes simples, le polymorphisme peut être expliqué comme une technique permettant de modifier la classe de base à l'aide de la classe dérivée, où les deux classes possèdent des propriétés différentes.

Le schéma suivant illustre le fonctionnement du polymorphisme :

Cette figure explique que l'argile est l'objet parent à partir duquel sont fabriqués les pots, les bols et les jouets. Tous ces objets sont différents les uns des autres, mais ils possèdent 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, l'argile.

Formes de polymorphisme

Vous trouverez ci-dessous les 2 formes de polymorphisme :

1. Surcharge des opérateurs

Un opérateur peut donner différentes sorties en fonction du type d'opérandes sur lesquels il opère. C'est ce qu'on appelle la surcharge de l'opérateur. Par exemple, l'opérateur « + » peut effectuer une addition sur deux entiers, alors qu'il peut concaténer deux chaînes. Ainsi un 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();
}
}
}

Sortie :

Cette sortie illustre la surcharge de l'opérateur pour ajouter deux nombres complexes. Le code montre la surcharge des opérateurs ainsi que la surcharge des fonctions.

2. Surcharge de fonctions

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 la 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 reste 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 du trait est l'organe prévu pour mouler l'argile. En fonction de différentes directions de trait, l'argile se transforme respectivement en pot, en bol et en 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<Clay>
{
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();
}
}
}

Sortie :

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 'Mould' 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 Mould, la méthode de la classe de base est remplacée par la méthode de la classe enfant. Ainsi, nous voyons le résultat de la méthode de classe enfant. Le code ci-dessus montre le remplacement de méthode et non la surcharge pour illustrer le polymorphisme.

Points à garder à l’esprit pour le polymorphisme en C#

Les points à garder à l'esprit pour le polymorphisme en C# :

• La surcharge est différente de la substitution. La surcharge a des signatures de fonction différentes tandis que la substitution a les mêmes signatures de fonction.
• Le polymorphisme fait référence à la modification 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 implémenter l'héritage. Il décide au moment de l'exécution d'appeler la méthode de la classe enfant en utilisant la substitution de méthode.

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!