Introduction à la surcharge et au 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 substitution sont utilisés pour y parvenir respectivement. En redéfinissant, 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 surcharge, il existe plusieurs méthodes dans une classe avec le même nom et des paramètres différents.
Comment remplacer et surcharger fonctionne en C #?
Le fonctionnement de la surcharge et de la surcharge en C # est expliqué ci-dessous avec des exemples:
Primordial
Il existe 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”);
)
)
Dans ce cas, des mots clés virtuels et de substitution sont utilisés, ce qui signifie que la classe de base est virtuelle et que la classe enfant peut implémenter cette classe et remplacer signifie que cette classe enfant a le même nom et la même signature de méthode que la classe parent.
Exemple 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, elle peut implémenter la méthode de la classe parent à sa manière. La méthode de classe enfant a un remplacement de mot clé qui montre que cette méthode est une méthode de remplacement.
Production:
Exemple # 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();
)
)
)
Production:
Dans cet exemple, la classe dérivée a un mot-clé de base qui est utilisé pour appeler la méthode de classe de base. Ainsi, dans ce cas, la méthode dérivée est appelée après la méthode de classe de base.
Points à retenir:
- Dans le concept prioritaire, le nom de la méthode et la signature de méthode et le modificateur d'accès sont toujours les mêmes que les classes parent et enfant.
- La méthode de classe parent ne peut pas être statique.
Surcharge
En surcharge, il existe plusieurs méthodes avec une signature de méthode différente. Voici 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 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 différent de paramètres. La première méthode se compose de deux paramètres tandis que la seconde a trois paramètres. C'est ce qu'on appelle la surcharge de méthode.
Production:
Exemple # 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. Dans ce cas, les paramètres varient donc en raison du type de données différent.
Production:
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, le nom des méthodes est le même mais l'ordre des paramètres est différent. La première méthode a un nom et un identifiant resp. tandis que le second a respectivement id et name.
Production:
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 nombre.
- Il n'est pas possible de surcharger une méthode basée sur les différents types de retour.
Avantages de la surcharge et de la surcharge en C #
- La surcharge est l'un des moyens d'obtenir de l'électricité statique et le dépassement est l'un des moyens par lesquels C # atteint le polymorphisme dynamique.
- Il offre une flexibilité à l'utilisateur et la propreté du code.
Conclusion
La surcharge et le dépassement jouent un rôle majeur dans la réalisation du polymorphisme. La substitution permet à la classe dérivée de s'implémenter à sa manière et, d'autre part, la surcharge concerne des méthodes portant le même nom et différents types d'implémentations de paramètres.
Articles recommandés
Ceci est un guide de surcharge et de remplacement en C #. Nous discutons ici du fonctionnement, de la syntaxe, des avantages de la surcharge et du remplacement en C # avec des exemples et l'implémentation de code. Vous pouvez également consulter les articles suivants pour en savoir plus -
- Objets en C #
- Tableaux 2D en C #
- Remplacement en C #
- Échange en C #
- Polymorphisme en Java
- Graphiques 2D en Java
- 3 différents types de tableaux en PHP (exemples)