abstract (Référence C#)
Mise à jour : novembre 2007
Le modificateur abstract peut être utilisé avec des classes, des méthodes, des propriétés, des indexeurs et des événements. Utilisez le modificateur abstract dans une déclaration de classe pour indiquer qu'une classe est destinée à être uniquement une classe de base d'autres classes. Les membres marqués comme abstraits, ou inclus dans une classe abstraite, doivent être implémenté par les classes qui dérivent de la classe abstraite.
Exemple
Dans cet exemple, la classe Square doit fournir une implémentation de Area puisqu'elle dérive de ShapesClass:
abstract class ShapesClass
{
abstract public int Area();
}
class Square : ShapesClass
{
int side = 0;
public Square(int n)
{
side = n;
}
// Area method is required to avoid
// a compile-time error.
public override int Area()
{
return side * side;
}
static void Main()
{
Square sq = new Square(12);
Console.WriteLine("Area of the square = {0}", sq.Area());
}
interface I
{
void M();
}
abstract class C : I
{
public abstract void M();
}
}
// Output: Area of the square = 144
Les classes abstraites présentent les fonctionnalités suivantes :
Une classe abstraite ne peut pas être instanciée.
Une classe abstraite peut contenir des méthodes abstraites et des accesseurs.
Il est impossible de modifier une classe abstraite à l'aide du modificateur sealed (Référence C#) car sealed empêche la classe d'être héritée.
Une classe non abstraite dérivée d'une classe abstraite doit inclure des implémentations réelles de tous les accesseurs et méthodes abstraites hérités.
Utilisez le modificateur abstract dans une déclaration de méthode ou de propriété pour indiquer que la méthode ou la propriété ne contient pas d'implémentation.
Les méthodes abstraites présentent les fonctionnalités suivantes :
Une méthode abstraite est implicitement une méthode virtuelle.
Les déclarations de méthodes abstraites sont autorisées uniquement dans les classes abstraites.
Comme une déclaration de méthode abstraite ne fournit aucune implémentation réelle, il n'y a pas de corps de méthode ; la déclaration de méthode se termine simplement par un point-virgule et la signature n'est pas suivie d'accolades ({ }). Par exemple :
public abstract void MyMethod();L'implémentation est fournie par une méthode de substitutionoverride (Référence C#), qui est membre d'une classe non abstraite.
L'utilisation des modificateurs static ou virtual dans une déclaration de méthode abstraite serait une erreur.
Les propriétés abstraites se comportent comme des méthodes abstraites, à l'exception des différences dans la syntaxe de déclaration et d'appel.
L'utilisation du modificateur abstract sur une propriété statique est une erreur.
Une propriété héritée abstraite peut être substituée dans une classe dérivée en incluant une déclaration de propriété qui utilise le modificateur override.
Pour plus d'informations sur les classes abstraites, consultez Classes abstract et sealed et membres de classe (Guide de programmation C#).
Une classe abstraite doit fournir une implémentation pour tous les membres d'interface.
Une classe abstraite qui implémente une interface peut mapper les méthodes d'interface sur des méthodes abstraites. Par exemple :
interface I
{
void M();
}
abstract class C : I
{
public abstract void M();
}
Dans cet exemple, la classe DerivedClass est dérivée d'une classe abstraite BaseClass. La classe abstraite contient une méthode abstraite, AbstractMethod, et deux propriétés abstraites, X et Y.
abstract class BaseClass // Abstract class
{
protected int _x = 100;
protected int _y = 150;
public abstract void AbstractMethod(); // Abstract method
public abstract int X { get; }
public abstract int Y { get; }
}
class DerivedClass : BaseClass
{
public override void AbstractMethod()
{
_x++;
_y++;
}
public override int X // overriding property
{
get
{
return _x + 10;
}
}
public override int Y // overriding property
{
get
{
return _y + 10;
}
}
static void Main()
{
DerivedClass o = new DerivedClass();
o.AbstractMethod();
Console.WriteLine("x = {0}, y = {1}", o.X, o.Y);
}
}
// Output: x = 111, y = 161
Dans l'exemple précédent, si vous tentez d'instancier la classe abstraite en utilisant une instruction comme celle-ci :
BaseClass bc = new BaseClass(); // Error
vous obtiendrez une erreur indiquant que le compilateur ne peut pas créer une instance de la classe abstraite 'BaseClass'.
Spécification du langage C#
Pour plus d'informations, consultez les sections suivantes dans Spécifications du langage C#.
1.6.5.4 Méthodes virtuelles, méthodes override et méthodes abstraites
10.1.1.1 Classes abstraites