abstract (référence C#)
Le modificateur abstract indique que l’élément en cours de modification a une implémentation manquante ou incomplète. Le modificateur abstract peut être utilisé avec des classes, des méthodes, des propriétés, des indexeurs et des événements. Dans une déclaration de classe, utilisez le modificateur abstract pour indiquer qu’une classe doit uniquement servir de classe de base pour d’autres classes, et ne pas être instanciée toute seule. Les membres définis comme abstraits doivent être implémentés par des classes non abstraites dérivées de la classe abstraite.
Exemple 1
Dans cet exemple, la classe Square doit fournir une implémentation de GetArea, car elle dérive de la classe Shape :
abstract class Shape
{
public abstract int GetArea();
}
class Square : Shape
{
private int _side;
public Square(int n) => _side = n;
// GetArea method is required to avoid a compile-time error.
public override int GetArea() => _side * _side;
static void Main()
{
var sq = new Square(12);
Console.WriteLine($"Area of the square = {sq.GetArea()}");
}
}
// Output: Area of the square = 144
Les classes abstraites présentent les caractéristiques suivantes :
Une classe abstraite ne peut pas être instanciée.
Une classe abstraite peut contenir des méthodes et accesseurs abstraits.
Il n’est pas possible de modifier une classe abstraite avec le modificateur sealed, car les deux modificateurs ont des significations opposées. Le modificateur
sealedempêche qu’une classe soit héritée et le modificateurabstractexige qu’une classe soit 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 abstraits hérités.
Dans une déclaration de méthode ou de propriété, utilisez le modificateur abstract pour indiquer que la méthode ou la propriété ne contient pas d’implémentation.
Les méthodes abstraites présentent les caractéristiques 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 pas d’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 override, 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 les méthodes abstraites, à l’exception des différences dans la syntaxe de déclaration et d’appel.
L’utilisation du modificateur
abstractsur une propriété statique serait une erreur.Une propriété abstraite héritée 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.
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 à des méthodes abstraites. Par exemple :
interface I
{
void M();
}
abstract class C : I
{
public abstract void M();
}
Exemple 2
Dans cet exemple, la classe DerivedClass est dérivée de la classe abstraite BaseClass. La classe abstraite contient une méthode abstraite, AbstractMethod, et deux propriétés abstraites, X et Y.
// Abstract class
abstract class BaseClass
{
protected int _x = 100;
protected int _y = 150;
// Abstract method
public abstract void AbstractMethod();
// Abstract properties
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()
{
var o = new DerivedClass();
o.AbstractMethod();
Console.WriteLine($"x = {o.X}, y = {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 obtenez une erreur indiquant que le compilateur ne peut pas créer une instance de la classe abstraite BaseClass.
Néanmoins, il est possible d’utiliser un constructeur de classe abstrait, comme dans l’exemple ci-dessous
Exemple 3
public abstract class Shape
{
public string Color { get; set; }
// Constructor of the abstract class
protected Shape(string color)
{
Color = color;
Console.WriteLine("Created a shape with color {color}.");
}
// Abstract method that must be implemented by derived classes
public abstract double CalculateArea();
}
public class Square : Shape
{
public double Side { get; set; }
// Constructor of the derived class calling the base class constructor
public Square(string color, double side) : base(color)
{
Side = side;
}
public override double CalculateArea()
{
return Side * Side;
}
}
public class Program
{
public static void Main(string[] args)
{
Square square = new Square("red", 5);
Console.WriteLine("Area of the square: {square.CalculateArea()}");
}
}
La classe Shape est déclarée abstract, ce qui signifie qu’elle ne peut pas être instanciée directement. Au lieu de cela, il sert de blueprint pour d’autres classes.
- Même si vous ne pouvez pas créer d’objets d’une classe abstraite, il peut toujours avoir un constructeur. Ce constructeur est généralement
protected, ce qui signifie qu’il n’est accessible qu’à partir de classes dérivées. Dans ce cas, le constructeurShapeprend un paramètrecoloret initialise la propriétéColor. Il imprime également un message dans la console. La partiepublic Square(string color, double side) : base(color)appelle le constructeur de la classe de base (Shape) et lui transmet l’argumentcolor. - Dans la classe Shape, le constructeur défini prend une couleur en tant que paramètre
protected Shape(string color). Cela signifie qu'il n'existe plus de constructeur sans paramètre par défaut automatiquement fourni par C#. Ainsi, les classes dérivées doivent utiliser l'expression: base(color)pour appeler le constructeur de base. La définition de la valeur par défaut sur la couleurprotected Shape(string color="green")permet d’omettre l’expression: base(color)dans les classes dérivées, toujours ce constructeurprotected Shape(string color="green")sera appelé, définissant la couleur sur vert.
Spécification du langage C#
Pour plus d'informations, voir la spécification du langage C#. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.
