Exporter (0) Imprimer
Développer tout

10.5.6 Méthodes abstraites

Visual Studio .NET 2003

Lorsqu'une déclaration de méthode d'instance comprend un modificateur abstract, cette méthode est dite méthode abstraite. Bien qu'une méthode abstraite constitue aussi implicitement une méthode virtuelle, elle ne peut pas avoir le modificateur virtual.

Une déclaration de méthode abstraite présente une nouvelle méthode virtuelle mais ne fournit pas une implémentation de cette méthode. Au lieu de cela, les classes dérivées non abstraites doivent fournir leur propre implémentation en se substituant à cette méthode. Puisqu'une méthode abstraite ne fournit aucune implémentation réelle, le method-body d'une méthode abstraite se compose simplement d'un point-virgule.

Les déclarations de méthode abstraite sont uniquement autorisées dans les classes abstraites (Section 10.1.1.1).

Dans l'exemple suivant

public abstract class Shape
{
   public abstract void Paint(Graphics g, Rectangle r);
}
public class Ellipse: Shape
{
   public override void Paint(Graphics g, Rectangle r) {
      g.DrawEllipse(r);
   }
}
public class Box: Shape
{
   public override void Paint(Graphics g, Rectangle r) {
      g.DrawRect(r);
   }
}

la classe Shape définit la notion abstraite d'un objet de forme géométrique qui peut se peindre lui-même : la méthode Paint est de type abstract car elle ne présente pas d'implémentation par défaut significative. Les classes Ellipse et Box sont des implémentations de Shape concrètes. Étant donné que ces classes ne sont pas abstraites, elles doivent absolument se substituer à la méthode Paint et fournir la véritable implémentation.

Une erreur de compilation est provoquée si un base-access (Section 7.5.8) fait référence à une méthode abstraite. Dans l'exemple suivant

abstract class A
{
   public abstract void F();
}
class B: A
{
   public override void F() {
      base.F();                  // Error, base.F is abstract
   }
}

Une erreur de compilation est signalée pour l'appel de base.F() car il fait référence à une méthode abstraite.

Une déclaration de méthode abstraite est autorisée à se substituer à une méthode virtuelle. Une classe abstraite peut ainsi forcer la réimplémentation de la méthode dans les classes dérivées, et rend l'implémentation originelle de la méthode non disponible. Dans l'exemple suivant

using System;
class A
{
   public virtual void F() {
      Console.WriteLine("A.F");
   }
}
abstract class B: A
{
   public abstract override void F();
}
class C: B
{
   public override void F() {
      Console.WriteLine("C.F");
   }
}

la classe A déclare une méthode virtuelle, la classe B substitue une méthode abstraite à cette méthode, et la classe C se substitue à la méthode abstraite afin de fournir sa propre implémentation.

Afficher:
© 2015 Microsoft