Surcharge et remplacement en C#

Le polymorphisme est l'un des concepts importants en C#. Il existe deux types de polymorphisme : le temps de compilation et le temps d'exécution. Les concepts de surcharge et de remplacement sont utilisés respectivement pour y parvenir. En cas de substitution, une classe enfant peut implémenter la méthode de classe parent d'une manière différente, mais la méthode de classe enfant a le même nom et la même signature de méthode que le parent alors qu'en cas de surcharge, il existe plusieurs méthodes dans une classe avec le même nom et des paramètres différents. 🎜>

Comment fonctionnent le remplacement et la surcharge en C# ?

Le fonctionnement du remplacement et de la surcharge en C# est expliqué ci-dessous avec des exemples :

Remplacement

Il y a certains mots-clés que nous utilisons pour remplacer comme virtual, override et base.

Syntaxe :

class Parent
{
public virtual void Example() // base class
{
Console.WriteLine("parent class");
}
}
class Child: Parent
{
public override void Example() // derived class
{
base.Example();
Console.WriteLine("Child class");
}
}

En cela, des mots-clés virtual et override sont utilisés, ce qui signifie que la classe de base est virtuelle et que la classe enfant peut implémenter cette classe et override signifie que cette classe enfant a le même nom et la même signature de méthode que la classe parent.

Exemple n°1

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverridingExample
{
class Subject           // base class
{
public virtual void study()              // base class method
{
Console.WriteLine("Study all the subjects");
}
}
class Mathematics: Subject      //  derived class
{
public override void study()        // derived class method
{
Console.WriteLine("Study Mathematics");
}
}
class Program
{
// main method
static void Main(string[] args)
{
Subject s = new Mathematics();
s.study();
Console.ReadLine();
}
}
}

Dans l'exemple ci-dessus, le nom des méthodes est le même mais leur implémentation est différente. La classe de base est virtuelle et, grâce à cette classe enfant, peut implémenter la méthode de la classe parent à sa manière. La méthode de la classe enfant a un remplacement de mot-clé qui montre que cette méthode est une méthode de remplacement.

Sortie :

Exemple n°2

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverridingExample
{
class Subject             // base class
{
public virtual void study()              // base class method
{
Console.WriteLine("Study all the subjects");
}
}
class Mathematics: Subject      //  derived class
{
public override void study()        // derived class method
{
base.study();
Console.WriteLine("Study Mathematics");
}
}
class Program
{
// main method
static void Main(string[] args)
{
Mathematics m = new Mathematics();
m.study();
Console.ReadLine();
}
}
}

Sortie :

Dans cet exemple, la classe dérivée a un mot-clé de base qui est utilisé pour appeler la méthode de la classe de base. Donc, dans ce cas, la méthode dérivée est appelée après la méthode de la classe de base.

Points à retenir :

Dans le concept primordial, le nom de la méthode, la signature de la méthode et le modificateur d'accès sont toujours les mêmes que ceux des classes parent et enfant.
La méthode de la classe parent ne peut pas être statique.

Surcharge

En surcharge, il existe plusieurs méthodes avec des signatures de méthode différentes. Vous trouverez ci-dessous quelques exemples qui montrent comment nous pouvons réaliser une surcharge en faisant varier le nombre de paramètres, l'ordre des paramètres et les types de données des paramètres.

Exemple n°1

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverloadingExample
{
class Demo
{
public int Sum(int x, int y)
{
int value = x + y;
return value;
}
public int Sum(int x, int y, int z)
{
int value = x + y + z;
return value;
}
public static void Main(string[] args) // main method
{
Demo d = new Demo();
int sum1 = d.Sum(24, 28);
Console.WriteLine("sum of the two "
+ "integer value : " + sum1);
int sum2 = d.Sum(10, 20, 30);
Console.WriteLine("sum of the three "
+ "integer value : " + sum2);
Console.ReadLine();
}
}
}

Dans l'exemple ci-dessus, il existe deux méthodes portant le même nom mais un nombre de paramètres différent.  La première méthode comprend deux paramètres tandis que la seconde comporte trois paramètres. C'est ce qu'on appelle la surcharge de méthode.

Sortie :

Exemple n°2

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverloadingExample
{
class Demo
{
public int Sum(int x, int y, int z)
{
int value = x + y + z;
return value;
}
public double Sum(double x, double y, double z)
{
double value = x + y + z;
return value;
}
public static void Main(string[] args) // main method
{
Demo d = new Demo();
int sum1 = d.Sum(24, 28,7);
Console.WriteLine("sum of the two "
+ "integer value : " + sum1);
double sum2 = d.Sum(10.0, 20.0, 30.0);
Console.WriteLine("sum of the three "
+ "integer value : " + sum2);
Console.ReadLine();
}
}
}

Dans l'exemple ci-dessus, il existe deux méthodes portant le même nom mais leurs types de données sont différents. La première méthode a un type de données entier tandis que la seconde a un type de données double. Donc, dans ce cas, les paramètres varient en raison du type de données différent.

Sortie :

Exemple #3

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverloadingExample
{
class Demo
{
public void Details(String name,int id)
{
Console.WriteLine("Name " + name + ", "
+ "Id " + id); ;
}
public void Details(int id,string name)
{
Console.WriteLine("Name " + name + ", "
+ "Id " + id);
}
public static void Main(string[] args) // main method
{
Demo d = new Demo();
d.Details("John", 10);
d.Details("Joe", 20);
Console.ReadLine();
}
}
}

Dans l'exemple ci-dessus, les noms des méthodes sont les mêmes mais l'ordre des paramètres est différent. La première méthode a un nom et un identifiant resp. alors que le second a respectivement un identifiant et un nom.

Sortie :

Points à retenir :

Dans un concept de surcharge, il n'est pas possible de définir plus d'une méthode avec les mêmes paramètres en cas d'ordre, de type et de numéro.
Il n'est pas possible de surcharger une méthode en fonction des différents types de retour.

Avantages de la surcharge et du remplacement en C#

Voici les avantages expliqués.

La surcharge est l'un des moyens d'obtenir un polymorphisme statique et la substitution est l'un des moyens par lesquels C# atteint le polymorphisme dynamique.
Il offre de la flexibilité à l'utilisateur et la propreté du code.

Conclusion

La surcharge et la substitution jouent un rôle majeur dans l'obtention du polymorphisme. La substitution permet à la classe dérivée de s'implémenter à sa manière et, d'autre part, la surcharge concerne les méthodes portant le même nom et différents types d'implémentations de paramètres.

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!