Introduction à la substitution en C #
La substitution en C # est la réimplémentation d'une méthode de classe de base dans une classe dérivée. Dans ce cas, la méthode de classe de base est remplacée dans la classe enfant. La méthode de classe dérivée a le même nom et la même signature que la méthode de classe de base. Le remplacement est utile pour obtenir le polymorphisme d'exécution.
Il existe quelques mots clés utilisés pour remplacer la méthode.
1. Virtuel - Ce mot-clé est utilisé avec une classe de base, ce qui signifie que la méthode d'une classe de base peut être remplacée.
public virtual void Method()
(
// implementation
)
2. Remplacer - Ce mot-clé est utilisé avec une classe dérivée qui signifie que la classe dérivée remplace une méthode d'une classe de base.
public override void Method()
(
// implementation
)
3. Base - Ce mot-clé est utilisé dans une classe dérivée pour appeler la méthode de classe de base.
public override void Method()
(
base.Method();
// implementation
)
Comment le remplacement fonctionne en C #?
Vous trouverez ci-dessous un exemple de la façon dont nous pouvons implémenter la substitution en C #.
class Parent
(
public virtual void Demo() // base class
(
Console.WriteLine(“This is parent”);
)
)
class Child: Parent
(
public override void Demo() // derived class
(
Console.WriteLine(“This is child”);
)
)
Dans l'exemple ci-dessus, il y a deux classes, l'une est la classe de base ou la classe parent et l'autre est la classe dérivée ou nous pouvons dire, la classe enfant. Une méthode de classe de base est dérivée en classe enfant. Dans ce cas, la méthode dans un parent est virtuelle, ce qui signifie qu'elle peut être remplacée par la classe enfant. La substitution dans un enfant signifie que cette méthode est identique à la méthode de classe parent avec la même signature de méthode.
Types de substitution en C #
Vous trouverez ci-dessous les exemples qui montrent la substitution avec divers mots clés.
Exemple 1 - sans mots-clés virtuels et de remplacement
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
(
class Bird // base class
(
public void fly() // base class method
(
Console.WriteLine("Birds are flying");
)
)
class Peacock : Bird // derived class
(
public new void fly() // derived class method
(
Console.WriteLine("Peacock is flying");
)
)
class Program
(
// main method
static void Main(string() args)
(
Bird b = new Peacock();
b.fly();
Console.ReadLine();
)
)
)
Dans l'exemple ci-dessus, aucun mot clé n'est utilisé dans les deux bases ni dans les méthodes dérivées.
Toujours dans la méthode principale, la référence parent est utilisée pour appeler la méthode enfant. Donc, dans ce cas, quand aucun mot clé n'est utilisé, la méthode parent est appelée à la place d'une méthode enfant. Ainsi, la sortie sera
Production :
Exemple 2 (a) - Avec des mots-clés virtuels et de remplacement
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
(
class Bird // base class
(
public virtual void fly() // base class method
(
Console.WriteLine("Birds are flying");
)
)
class Peacock : Bird // derived class
(
public override void fly() // derived class method
(
Console.WriteLine("Peacock is flying");
)
)
class Program
(
// main method
static void Main(string() args)
(
Bird b = new Peacock();
b.fly();
Console.ReadLine();
)
)
)
Dans cet exemple, virtual est utilisé dans la classe de base, ce qui signifie qu'il donne à la classe enfant le pouvoir d'implémenter la méthode à sa manière. Dans une classe dérivée, le remplacement est utilisé, ce qui signifie que la méthode enfant est la méthode de remplacement. Les deux méthodes sont identiques avec le même nom et la même signature de méthode, mais la partie implémentation est différente. Dans cet exemple également, la référence parent est utilisée pour appeler la méthode enfant. Mais comme un parent est une méthode virtuelle, la méthode enfant est appelée en premier au lieu de la méthode parent. Ainsi, la sortie sera
Production :
Exemple 2 (b) - Mots-clés virtuels et de remplacement
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
(
class Bird // base class
(
public virtual void fly() // base class method
(
Console.WriteLine("Birds are flying");
)
)
class Peacock : Bird // derived class
(
public override void fly() // derived class method
(
Console.WriteLine("Peacock is flying");
)
)
class Program
(
//main method
static void Main(string() args)
(
Peacock p = new Peacock();
p.fly();
Console.ReadLine();
)
)
)
Cet exemple est le même que l'exemple précédent mais cette méthode enfant est utilisée comme référence.
Production :
Exemple 3 - Avec le mot-clé de base
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
(
class Bird // base class
(
public virtual void fly() // base class method
(
Console.WriteLine("Birds are flying");
)
)
class Peacock : Bird // derived class
(
public override void fly() // derived class method
(
base.fly(); // base is use to call parent method
Console.WriteLine("Peacock is flying");
)
)
class Program
(
static void Main(string() args)
(
Peacock p = new Peacock();
p.fly();
Console.ReadLine();
)
)
)
Dans l'exemple ci-dessus, la base est utilisée dans une classe dérivée pour appeler la méthode de classe de base. Donc, dans cette méthode de base est appelée d'abord, puis la méthode dérivée.
Production :
Exemple 4 - Classes abstraites avec redéfinition
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
(
abstract class Calculate
(
public abstract int sum();
)
class Values : Calculate // derived class
(
int val1;
int val2;
public Values(int a = 0, int b = 0)
(
val1 = a;
val2 = b;
)
public override int sum()
(
Console.WriteLine("sum of two values");
return (val1 + val2);
)
)
class Program
(
static void Main(string() args)
(
Values v = new Values(10, 20);
int a = v.sum();
Console.WriteLine(a);
Console.ReadLine();
)
)
)
Dans l'exemple ci-dessus, une méthode abstraite est utilisée. Une classe abstraite est implémentée par la classe dérivée qui contient une méthode abstraite.
Production :
Règles de substitution de méthode
- La signature de méthode d'une classe dérivée doit être identique à une classe de base.
- La substitution n'est pas possible dans la même classe.
- Les modificateurs d'accès doivent être les mêmes pour les méthodes virtuelles et les méthodes de substitution.
- Le mot-clé virtuel est utilisé dans la méthode de classe de base et Override est utilisé dans une méthode de classe dérivée.
- La méthode de classe de base ne doit pas être statique.
Conclusion
La substitution est utile dans le polymorphisme d'exécution. Il permet à la classe dérivée d'implémenter une méthode de classe de base à sa manière. L'implémentation de la méthode est donc différente de la classe dérivée de sa classe de base. La méthode redéfinie peut être virtuelle, redéfinie ou abstraite.
Articles recommandés
Ceci est un guide de remplacement en C #. Ici, nous discutons de la façon d'utiliser des mots clés de substitution et différents pour la substitution en C # avec des exemples. Vous pouvez également consulter nos autres articles suggérés -
- Gestion des exceptions en C #
- Tableaux en C #
- Remplacement de méthode en C #
- Variables en C #
- Modificateurs d'accès en PHP
- Polymorphisme en Java
- Classes abstraites en JavaScript
- Exemples de ce mot-clé