En C#, une hiérarchie de classes peut être définie à l'aide de l'héritage, qui permet à une classe dérivée (Car) d'hériter du comportement et des données de sa classe parente (Vehicle). Si aucune classe parente n'est spécifiée, la classe hérite de la classe object.
Les classes parentes peuvent fournir des fonctionnalités aux classes dérivées de trois manières :
virtual, qui est comme une méthode ordinaire mais que les classes dérivées peuvent modifier.abstract, qui est une méthode sans implémentation que les classes dérivées doivent implémenter. Une classe qui possède des méthodes abstract doit elle aussi être marquée comme abstract. Les classes abstraites ne peuvent pas être instanciées.Le modificateur d'accès protected permet d'accéder à un membre d'une classe parente depuis une classe dérivée, mais bloque l'accès depuis les autres classes. Les classes dérivées peuvent donc accéder aux membres public et protected de la classe parente, mais pas à ses membres private.
Les classes dérivées peuvent accéder aux membres de la classe parente grâce au mot-clé base.
// Inherits from the 'object' class
abstract class Vehicle
{
// Can be overridden
public virtual void Drive()
{
}
// Must be overridden
protected abstract int Speed();
}
// Cannot be inherited from
sealed class Car : Vehicle
{
public override void Drive()
{
// Override virtual method
// Call parent implementation
base.Drive();
}
protected override int Speed()
{
// Implement abstract method
}
}
Le constructeur d'une classe dérivée appelle automatiquement le constructeur de sa classe parente avant d'exécuter la logique de son propre constructeur. On peut passer des arguments au constructeur d'une classe parente à l'aide du mot-clé base. Comme les classes abstraites ne peuvent pas être instanciées, leurs constructeurs peuvent être déclarés protected.
abstract class Vehicle
{
protected Vehicle(int wheels)
{
Console.WriteLine("Called first");
}
}
class Car : Vehicle
{
public Car() : base(4)
{
Console.WriteLine("Called second");
}
}
Lorsque plusieurs classes dérivent d'une classe de base, les deux (ou plus) sous-classes implémentent souvent des versions différentes d'une méthode de la classe de base. C'est un principe très important appelé polymorphisme. Par exemple, dans une variante de l'exemple ci-dessus, on montre comment du code qui utilise Vehicle peut changer de comportement selon le type de véhicule qui a été instancié.
abstract class Vehicle
{
public abstract string GetDescription();
}
class Car : Vehicle
{
public Car()
{
}
public override string GetDescription()
{
return "Runabout";
}
}
class Rig : Vehicle
{
public Rig()
{
}
public override string GetDescription()
{
return "Big Rig";
}
}
Vehicle v1 = new Car();
Vehicle v2 = new Rig();
v1.GetDescription();
// => Runabout
v2.GetDescription();
// => Big Rig
Pour empêcher qu'une classe soit héritée, ajoute le modificateur sealed. Certains praticiens essaient d'éviter d'hériter de classes concrètes (comme le montre cette question sur Stack Overflow), et le modificateur sealed va dans ce sens. D'un autre côté, de nombreux développeurs C# le considèrent comme un frein à la maintenance, comme le montrent certains commentaires de cette question. Le conseil est d'utiliser le modificateur sealed avec parcimonie jusqu'à ce que tu aies acquis suffisamment de confiance dans son utilisation pour tes besoins.
L'article suivant décrit new comme une alternative au modificateur override. Cela peut parfois être utile, notamment avec des hiérarchies de classes alambiquées et/ou une sorte de conflit entre bibliothèques.