virtual/override/sealed et classes abstraites
Découvrez les méthodes virtual, la redéfinition, le scellement des redéfinitions et les classes abstraites ; voyez comment les références de base sélectionnent les implémentations dérivées.
virtual/override/sealed et classes abstraites est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 3 leçons au total.
Notions de base sur l’héritage
Objectif : réutiliser et personnaliser le comportement grâce à l’héritage.
- virtual dans la classe de base
- override dans la classe dérivée
- sealed override pour empêcher d’autres modifications
- classe abstract définissant un contrat et du code partagé
virtual et override
virtual permet la redéfinition. Les appels effectués via une reference de base utilisent la redéfinition de la classe dérivée (liaison dynamique).
using System;
// Base method is virtual so derived classes can customize it
public class Shape
{
public virtual double Area()
{
return 0.0; // default
}
}
public class Rectangle : Shape
{
public int Width { get; private set; }
public int Height { get; private set; }
public Rectangle(int w, int h)
{
Width = w; Height = h;
}
public override double Area()
{
return Width * Height;
}
}
public class Program
{
public static void Main(string[] args)
{
Shape s = new Shape();
Shape r = new Rectangle(3, 4); // base reference
Console.WriteLine("Shape area = " + s.Area());
Console.WriteLine("Rectangle area = " + r.Area()); // calls Rectangle.Area()
}
}
sealed override
Utilisez sealed override pour verrouiller une méthode à un niveau donné de la hiérarchie.
using System;
public class BaseLogger
{
public virtual string Prefix()
{
return "[LOG]";
}
}
public class ConsoleLogger : BaseLogger
{
public sealed override string Prefix()
{
return "[CONSOLE]";
}
}
// Further derived class cannot override Prefix again:
// public class FancyLogger : ConsoleLogger
// {
// public override string Prefix() { return "[FANCY]"; } // compile error
// }
public class Program
{
public static void Main(string[] args)
{
ConsoleLogger log = new ConsoleLogger();
Console.WriteLine(log.Prefix() + " Ready");
}
}
Classes abstract
Les classes abstract définissent les membres requis (abstract) et peuvent également fournir du code partagé.
using System;
// Abstract class: cannot be instantiated; must implement abstract members
public abstract class Animal
{
public abstract string Speak(); // no body here
public string Info()
{
return "Animal says: " + Speak(); // shared code uses the abstract member
}
}
public class Dog : Animal
{
public override string Speak()
{
return "Woof";
}
}
public class Program
{
public static void Main(string[] args)
{
// Animal a = new Animal(); // compile error: abstract
Animal d = new Dog();
Console.WriteLine(d.Info()); // calls Dog.Speak()
}
}
virtual ou abstract
Choisissez :
- virtual : fournit un corps par défaut que les types dérivés peuvent redéfinir.
- abstract : aucun corps ; les types dérivés doivent l’implémenter.
- sealed override : empêche toute nouvelle redéfinition une fois le comportement fixé.
Appels polymorphes
Le polymorphisme permet à une méthode d’accepter le type de base et d’appeler les membres redéfinis sur les instances dérivées.
using System;
public class Notifier
{
public virtual string Channel() { return "Base"; }
}
public class EmailNotifier : Notifier
{
public override string Channel() { return "Email"; }
}
public class SmsNotifier : Notifier
{
public override string Channel() { return "SMS"; }
}
public class Program
{
// Works with any Notifier (polymorphism)
static void Send(Notifier n, string msg)
{
Console.WriteLine("[" + n.Channel() + "] " + msg);
}
public static void Main(string[] args)
{
Send(new EmailNotifier(), "Hello");
Send(new SmsNotifier(), "Hi");
}
}
Règle virtual/override/sealed
Récapitulatif
Récapitulatif : marquez les méthodes de base avec virtual, redéfinissez-les dans les types dérivés et utilisez sealed override pour verrouiller le comportement. Utilisez les classes abstract pour imposer des implémentations tout en partageant du code commun.
Questions Fréquemment Posées
La leçon « virtual/override/sealed et classes abstraites » est-elle gratuite ?
Oui — le texte complet de « virtual/override/sealed et classes abstraites » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 3 leçons au total.
Qu'est-ce que j'apprendrai dans « virtual/override/sealed et classes abstraites » ?
Découvrez les méthodes virtual, la redéfinition, le scellement des redéfinitions et les classes abstraites ; voyez comment les références de base sélectionnent les implémentations dérivées. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer C# Academy ?
Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 3.
Combien de temps prend la leçon « virtual/override/sealed et classes abstraites » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?
Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- virtual/override/sealed et classes abstraites
- Interfaces (introduction) et implémentation de plusieurs interfaces
- Polymorphisme et répartition dynamique