Les interfaces d'objet sous Delphi

Testé sous Delphi 2006.
Version 1.0

Les fichiers sources des différents exemples :
FTP ;
HTTP.

III-A. Méthode abstraite▲

III-B. Classe abstraite▲

Ici le mot interface n'a aucun rapport ni avec une interface utilisateur (IHM) ni avec la section interface d'une unité Delphi.

Une interface est une abstraction. Elle est une spécification formelle de classe et est utilisée pour définir la limite entre sa spécification et son implémentation, on laisse ainsi aux classes la liberté de son implémentation.
En d'autres termes une interface est le quoi et une classe définit le comment.

Au niveau du langage Delphi, une interface est un type semblable à une classe abstraite, elle ne contient que des méthodes abstraites par défaut, il n'est pas nécessaire de spécifier le mot clé abstract dans leurs déclarations.
Une interface ne décrit aucune structure de données, car elle ne peut contenir aucun attribut, elle n'a aucune donnée.
En revanche elle peut contenir des propriétés au travers d'appel de méthodes d'accesseurs (Set et Get).
Elle est une possibilité d'encapsulation complète.

Une interface définit une aptitude à faire quelque chose, par exemple une itération sur un ensemble de données, ou un comportement de déplacement dans un espace 2D.
Un des objectifs des interfaces est de diminuer le couplage entre deux classes, c'est-à-dire le degré de dépendance d'une classe par rapport à une autre, ce qui facilite la maintenance.

L'interface permet de ne présenter au client que ce qui l'intéresse, dans ce tutoriel nous l'illustrerons en abordant les méthodes pouvant être liées au déplacement d'un être ou d'une chose.

L'usage d'une interface à la place d'une classe, permet de modifier l'implémentation de l'abstraction, ici le déplacement, sans impacter la ou les classes utilisatrices, l'interface faisant office d'écran.

Prenons un exemple, généralement la notion de déplacement, commune aux êtres ou aux objets, tombe sous le sens en revanche sa spécialisation au sein de la classe serpent ou flèche d'arc est radicalement différente. Une interface permettrait ici, dans un contexte précis, de s'intéresser à l'essentiel : ce que ça fait et pas comment ça le fait.

En quelque sorte une interface répond à la question que l'on pourrait poser à une classe : Est-ce que tu sais faire ça ?
La réponse qui nous importe ici est oui ou non, et c'est tout. La manière de le faire, c'est-à-dire comment est rempli le contrat, nous importe relativement peu.

Le terme de contrat est souvent employé pour définir la convention par laquelle une interface interagit avec une classe, mais ce qui importe c'est plus le respect de ce que l'interface est censée faire que l'acte qui enregistre cette convention. Dans la vie on peut prendre des engagements ou signer tous les contrats que l'on veut, rien ne nous empêche de ne pas les respecter. Je serais tenté de dire plus simplement qu'une interface respecte toujours l'engagement pris sur le comportement qu'elle propose et dans le cas contraire la sanction est simple et sans appel, la compilation échoue.

Chargez le projet interface1.

Par convention, le nom d'une interface est préfixé par la lettre I en majuscule et son nom définit clairement son comportement.
Déclarons une interface proposant la capacité de se déplacer :

Type 
IDeplacable =Interface
   Procedure Deplace; // Méthodes abstraites par défaut
   Procedure Arret;
end ;

On utilisera, par exemple la méthode Deplace non pas via une instance de classe, mais au travers d'une variable du type de l'interface souhaité, on parlera donc dans ce cas de référence d'interface.
Sachez qu'une variable d'interface, ici la variable MonInterface, est initialisée à Nil lors de sa déclaration :

Procedure TestInterface(UneInterface : IDeplacable);
begin
 If assigned(UneInterface)
  then Writeln('L''interface est assignee.')
  else Writeln('L''interface n''est pas assignee.');
end;

var MonInterface : IDeplacable;
begin
 TestInterface(MonInterface);
end.

Créons une interface en utilisant le code suivant :

var MonInterface : IDeplacable;
begin
 MonInterface:=IDeplacable.Create;
end.

malheureusement ce code provoque l'erreur de compilation : « Type record, object ou class requis ».

Afin d'utiliser notre interface IDeplacable nous devons déclarer une classe l'implémentant :

  TChose= Class(TObject, IDeplacable)
   Distance : Integer 
  end;

Le premier type déclaré doit être impérativement une classe, ici TObject, suivie d'une ou plusieurs interfaces, ici IDeplacable.
Ajoutons la création de l'instance de la classe TChose :

begin
 TestInterface(MonInterface);
 UneChose:=TChose.Create;
 readln;
end;

La compilation du code précédent nous renvoie, entre autres, les erreurs suivantes :

Identificateur non déclaré : Deplace
Identificateur non déclaré : Arret

Elles confirment que les méthodes de l'interface IDeplacable sont bien abstraites et doivent être implémentées par la classe TChose. Les simples déclarations des méthodes de l'interface sont insuffisantes, dans ce cas on retrouve une erreur classique : « Déclaration forward ou external non satisfaite : ' TChose.Deplace' ».

Implémentons donc les deux méthodes de l'interface :

TChose= Class(TObject,IDeplacable)
   Distance : Integer;
      //IDeplacable
   Procedure Deplace(Const Param:String);
   Procedure  Arret;
      //TChose
End;

{ TChose }
procedure TChose.Arret;
begin
 Writeln('Arret : IDeplacable de TChose ');
end;

procedure TChose.Deplace(const Param: String);
begin
  Writeln('Deplace : IDeplacable de TChose ');
end;

Ici la compilation nous renvoie la même erreur, mais pour les méthodes nommées QueryInterface, _AddRef et _Release. Bien que nous respections le contrat de l'interface IDeplacable, notre classe est soumise au respect du contrat de l'interface héritée IInterface. Du fait que, comme une classe, une interface hérite de toutes les méthodes de ses ancêtres, on doit implémenter toutes ces méthodes.

IInterface est l'ancêtre de base de toutes les interfaces, les déclarations suivantes :

type
 IDeplacable =interface

 IDeplacable =interface(IInterface)

sont donc identiques.

Voici la déclaration de l'interface IInterface :

type
  IInterface = interface
    ['{00000000-0000-0000-C000-000000000046}']
    function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall;
    function _AddRef: Integer; stdcall;
    function _Release: Integer; stdcall;
  end;

Elle permet de gérer ou créer des interfaces COM sous Delphi. On peut également voir dans le code source de l'unité System.pas la déclaration suivante

IUnknown = IInterface;

Les trois méthodes de IInterface sont donc celles de IUnknown. Sous Delphi hériter de IUnknown au lieu de IInterface informe le compilateur que l'interface doit être compatible avec les objets COM.

Chargez le projet Interface2.
L'interface IUnknown est l'ancêtre des interfaces sous COM et possède son propre identifiant d'interface(IID), chaque objet COM doit l'implémenter. Les méthodes de l'interface IUnknown permettent de gérer le cycle de vie des objets et d'obtenir les autres interfaces gérées par le composant.

Dans la déclaration de IInterface, la partie optionnelle ['{00000000-0000-0000-C000-000000000046}'] spécifie un GUID qui permet d'identifier de manière unique une interface. Ce GUID est nécessaire pour l'interrogation d'interface via l'appel à la méthode QueryInterface.

VIII-A. Un compteur de références▲

VIII-B. La méthode QueryInterface▲

VIII-C. La méthode _AddRef▲

VIII-D. La méthode _Release▲

Chargez le projet Interface3.
Revenons à notre code d'origine et utilisons la procédure TestInterface :

Procedure TestInterface(UneInterface : IDeplacable);
begin
 If assigned(UneInterface)
  then
   begin
    Writeln('L''interface est assignee.');
    UneInterface.Deplace('Méthode d''''interface''');
   end
  else Writeln('L''interface n''est pas assignee.');
end;

Appelons-la avec en paramètre une instance de classe au lieu d'une référence d'interface.

UneChose:=TChose.Create;
 TestInterface(UneChose);
 readln;

On peut voir qu'il n'y a aucun problème particulier ni lors de la compilation ni lors de l'exécution. Par contre l'ajout, dans la procédure TestInterface, des lignes suivantes :

UneInterface.ProcedureDeTChose;
 Inc(UneInterface.Distance,10);

provoque, lors de la compilation, l'erreur : « Identificateur non déclaré ».
L'interface ne connaît rien de l'objet associé, car comme il a été dit précédemment on s'attache à l'essentiel en respectant le contrat passé. En revanche l'implémentation d'une méthode d'une interface peut manipuler des données de l'instance de classe :

procedure TChose.Deplace;
begin
  Writeln('Deplace : IDeplacable de TChose');
  Inc(Distance,10);
end;

On peut donc dire que TChose.Deplace est égale à IDeplace.Deplace mais pas que TChose est égale à IDeplace.

On ne peut pas transtyper IDeplace en TChose en revanche TChose peut être transtypé en IDeplace, plus précisément il s'agit d'une conversion de type implicite. C'est ce qui se passe lors de l'appel à la procédure TestInterface, bien que cela soit le compilateur qui effectue cette opération à notre place. Il ne s'agit pas vraiment d'un transtypage, car le type de l'interface est connu lors de la compilation. Il n'y a donc pas d'interrogation de la table des méthodes des interfaces (IMT).

Le code suivant crée un objet TChose puis récupère son interface IDeplacable qui permet l'appel de la méthode Deplace via la variable MonInterface et enfin décrémente le compteur de référence de l'interface.

UneChose:=TChose.Create;
 MonInterface:=UneChose;  //Affectation
                          //transtypage implicite lors de la compilation 
 MonInterface.Deplace;
 MonInterface:=Nil;
 UneChose.Free;

Appel de TChose._AddRef
 Deplace : IDeplacable de TChose
 Appel de TChose._Release

IX-A. Les problématiques de transtypage des interfaces▲

var MonInterface : IDeplacable;
    UnObjet :TObject;

begin
 UnObjet:=TObject.Create;

{1}  MonInterface:=UnObjet;
{2}  if UnObjet is IDeplacable then writeln('Un objet est une interface IDeplacable.');
{3}  MonInterface:=UnObjet as IDeplacable;
{4}  MonInterface:=IInterface(UnObjet) as IDeplacable;
{5}  MonInterface:=IUnknown(UnObjet) as IDeplacable;
{6} if Not Supports(UnObjet,IDeplacable)
     then  Writeln('la classe TObject ne supporte pas l''interface IDeplacable.');
 
 UnObjet.Free;
 readln;
end.

if Not Supports(UnObjet,IDeplacable)
  then  Writeln('la classe TObject ne supporte pas l''interface IDeplacable.');

  IDeplacable=interface(IInterface)
  ['{62CAE27F-94C1-4A3D-B94F-F08FF36207D5}'] // GUID nécessaire pour l'opération de cast

type 
  IMesurable=interface(IInterface)
   Function Dimension:Integer;
  End;

...
var MonInterface : IDeplacable;
    Taille : IMesurable;
    UneChose: TChose;
begin
 UneChose:=TChose.Create;
 if Not Supports(UneChose,IDeplacable)
  then  Writeln('la classe TChose ne supporte pas l''interface IDeplacable.');
 
 MonInterface:=UneChose as IDeplacable;

  //TChose= Class(TObject,IDeplacable)
  TChose= Class(TInterfacedObject,IDeplacable)

  TChose= Class(TObject,IInterface,IDeplacable)

Appel de TChose.QueryInterface
 Appel de TChose._AddRef

Taille:=UneChose as IMesurable;

try
  Taille:=UneChose as IMesurable; // cf. la procédure interne à Delphi System._IntfCast
  except
  On E :EIntfCastError do
   begin
    Writeln('Exception :');
    Writeln(E.Message);
   end;
 end;

Appel de TChose.QueryInterface
Exception :
Interface non supportée

La classe TInterfacedObject implémente l'interface IUnknown et peut être utilisée comme base simple pour des classes compatibles COM car cette classe implémente un compteur de référence.

Dans Delphi, un descendant de TInterfacedObject n'a pas de fabricant de classes ni de CLSID(CLaSs IDentifier). Cela signifie qu'il ne peut être instancié qu'en appelant un constructeur.

Nous utiliserons désormais les interfaces sans variable d'instance de classe ce qui implique une création différente :

var MonInterface : IDeplacable;
    UneChose : TChose;

begin
 MonInterface:=TChose.Create; //Crée une interface
 UneChose:=MonInterface; 
end;

Lors de la création de l'interface le compilateur ajoute un appel à _AddRef.
La seconde ligne provoque à la compilation l'erreur : Type incompatible TChose et IDeplacable. Ce qui confirme une fois de plus qu'une interface n'est pas une classe.

Désormais l'implémentation de IUnknown, dans la classe TInterfacedObject, gère à notre place la destruction des interfaces. Bien qu'étant déchargé de cette opération il reste quelques erreurs à ne pas commettre. N'ayant plus la main sur l'implémentation des méthodes de IUnknown, utilisons le destructeur de la classe implémentant notre interface pour afficher le moment où elle est détruite.

XI-A. Règle de portée▲

Procedure PorteeInterface;
begin
 Writeln('Appel de la procedure PorteeInterface.');
  MonInterface.Deplace;
end;

begin
 MonInterface:=TChose.Create; //Creé une interface
 PorteeInterface;
 Writeln;
 Readln;

MonInterface:=TChose.Create; //Creé une interface
 MonInterface:=Nil; 
 PorteeInterface;

Procedure PorteeInterface2;
Var lInterface : IDeplacable;
begin
 Writeln('Appel de la procedure PorteeInterface2.');
  lInterface:=TChose.Create; //Creé une interface
  lInterface.Deplace;
end;

Procedure PorteeInterface3;
begin
 Writeln('Appel de la procedure PorteeInterface3.');
  IDeplacable(TChose.Create).Deplace; 
end;

XI-B. Rappel sur le transtypage▲

procedure ImpactDuTranstypageSurLeCompteurDeReference;
var UneReference : IUnknown;
    Interface1 : IDeplacable;

begin
 Writeln('Appel de la procedure ImpactDuTranstypageSurLeCompteurDeReference.');
 Interface1:=TChose.Create;
 UneReference:= Interface1 as IUnknown;
 Interface1:=Nil;
 Writeln('Fin de la procedure.');
end;

Interface1:=Nil;
 UneReference := Nil; //Force la libération de l'interface
 Writeln('Fin de la procedure.');

XI-C. Mixage d'usage de référence et d'instance de classe▲

var MonInterface : IDeplacable;
    UneChose : TChose;

begin
 UneChose:=TChose.Create;
 MonInterface:=UneChose;

 if Assigned(UneChose) 
  then FreeAndNil(UneChose);

 readln;
end.

MonInterface:=UneChose;
 MonInterface:=Nil;

procedure TInterfacedObject.BeforeDestruction;
begin
  if RefCount <> 0 then
    Error(reInvalidPtr);
end;

XI-D. Signature de méthode▲

procedure beep(x: ITest);
function test_func()
var
  y: ITest;
begin
  y := TTest.Create; // comme y est de type ITest, le compteur de références vaut 1
  beep(y); // l'appel de la fonction beep incrémente le compteur de références
  // et le décrémente à son retour
  y.something; // l'objet est toujours là avec un compteur de références valant 1
end;

function test_func()
var
  x: TTest;
begin
  x := TTest.Create; // pas encore de compteur de références pour l'objet
  beep(x as ITest); // le compteur est incrémenté par l'appel de beep
  // et décrémenté à son retour
  x.something; // surprise ! l'objet n'est plus là
end;

procedure beep(const x: ITest);

procedure beep(var x: ITest);

Extrait du « Guide du langage Pascal Objet », chapitre 10-1. Coppyright © 1983, 2001 Borland Software Corporation.

• La liste des membres ne peut contenir que des méthodes et des propriétés ; les champs ne sont pas autorisés dans les interfaces.
• Une interface n'ayant pas de champ, les spécificateurs de propriété read et write doivent être des méthodes (puisque les champs ne sont pas utilisables).
• Tous les membres d'une interface sont publics. Les spécificateurs de visibilité et de stockage ne sont pas autorisés (il est par contre possible d'utiliser default avec une propriété tableau).
• Les interfaces n'ont ni constructeurs ni destructeurs. Elles ne peuvent être instanciées, si ce n'est via des classes qui implémentent leurs méthodes. Il n'est pas possible de déclarer des méthodes comme étant virtual, dynamic, abstract ou override. Comme les interfaces n'implémentent pas leurs propres méthodes, ces directives sont dépourvues de sens.

XII-A. Propriétés d'interface▲

Chargez le projet Polymorphe
Les interfaces facilitent les traitements polymorphiques sur des classes ne possédant pas d'ancêtres communs.

Extrait de l'aide en ligne de Delphi :
L'utilisation d'interfaces vous permet de séparer la manière d'utiliser une classe de la manière dont elle est implémentée. Deux classes peuvent implémenter la même interface sans descendre de la même classe de base. En obtenant une interface à partir d'une classe, vous pouvez appeler les mêmes méthodes sans avoir à connaître le type de la classe. Cette utilisation polymorphe de la même méthode pour des objets sans rapport entre eux est possible, car les objets implémentent la même interface.
Voir l'exemple du cours de Didier Mailliet en page 144-116.

type
  IDeplacable=interface(IInterface)
  ['{62CAE27F-94C1-4A3D-B94F-F08FF36207D5}']
   Procedure Deplace;
  End;

  TChose= Class(TInterfacedObject,IDeplacable)
   Procedure Deplace;
  end;

  TEtre= Class(TInterfacedObject,IDeplacable)
   Procedure Deplace;
  end;
...
var InterfaceDeplace :IDeplacable;

begin
 InterfaceDeplace:=TChose.Create;
 InterfaceDeplace.Deplace;
 InterfaceDeplace:=Nil;

 InterfaceDeplace:=TEtre.Create;
 InterfaceDeplace.Deplace;
 InterfaceDeplace:=Nil;
end.

XIII-A. Procédure générique▲

procedure DeplaceTout(AInterface: array of IDeplacable);
var
 I: Integer;
begin
 for I := Low(AInterface) to High(AInterface) do
  AInterface[I].Deplace;
end;

var InterfaceChose,
    InterfaceEtre :  IDeplacable;

begin
 InterfaceChose:=TChose.Create;
 InterfaceEtre:=TEtre.Create;
 DeplaceTout([InterfaceChose,InterfaceEtre]);
 InterfaceChose:=Nil;
 InterfaceEtre:=Nil;

 readln;
end.

XIV-A. L'héritage multiple d'interface▲

  IMoteur=Interface
   procedure Demarrer;
   Procedure Stopper;
  end;

  ICarrosserie=Interface
   Procedure GetPortes;
  end;

  IVoiture=Interface(IMoteur,ICarrosserie)
   Procedure GetPlace;
  end;

XIV-B. Multihéritage de classe▲

XV-A. Entre une classe et une interface▲

TChose= Class(TInterfacedObject,IDeplacable)
    //TChose
   Distance : Integer;
    //IDeplacable
   Procedure Deplace;
   Procedure  Arret;
    //TChose
   Procedure ProcedureDeTChose;
   Procedure Deplace; //Collision de nom
   Destructor Destroy;Override;
  end;

TChose= Class(TInterfacedObject,IDeplacable)
    //TChose
   Distance : Integer;
    //IDeplacable
   Procedure IDeplacable.Deplace=DeplaceDeInterface;//Redirection de l'implémentation
   Procedure  Arret;
    //TChose
   Procedure ProcedureDeTChose;
   Procedure Deplace;
   Procedure DeplaceDeInterface; //Implémentation réelle de IDeplacable.Deplace
   Destructor Destroy;Override;
  end;

XV-B. Entre deux interfaces distinctes▲

  IDeplacable=interface(IInterface)
  ['{8C73D412-47C0-4D42-A492-B6F40433E338}']
   Procedure Deplace;
   Procedure  Arret;
  End;

  IExecutable=interface(IInterface)
  ['{E8CCF73F-A41A-45C9-ABEE-2DD422CD78B4}']
   Procedure Demarrage;
   Procedure  Arret; //Nom de méthode dupliqué
  End;

  TChose= Class(TInterfacedObject,IDeplacable,IExecutable)
    //TChose
   Distance : Integer;

    //IDeplacable
   Procedure Deplace;
   Procedure  Arret;

    //IExecutable
   Procedure Demarrage;

    //TChose
   Procedure ProcedureDeTChose;
   procedure Stop;
   Destructor Destroy;Override;
  end;

  TChose= Class(TInterfacedObject,IDeplacable,IExecutable)
    //TChose
   Distance : Integer;

    //IDeplacable
   Procedure Deplace;
   Procedure IDeplacable.Arret=Stop;

    //IExecutable
   Procedure Demarrage;
   Procedure  Arret;

    //TChose
   Procedure ProcedureDeTChose;
   procedure Stop;
   Destructor Destroy;Override;
  end;

XV-C. Entre des interfaces héritées▲

type
  IDeplacable=interface(IInterface)
  ['{8C73D412-47C0-4D42-A492-B6F40433E338}']
   Procedure Deplace;
   Procedure Arret;
  End;

  IExecutable=interface(IDeplacable)
  ['{E8CCF73F-A41A-45C9-ABEE-2DD422CD78B4}']
   Procedure Demarrage;
   Procedure Arret;
  End;

   //Collision de nom de méthode
  TChose= Class(TInterfacedObject,IExecutable)
    //TChose
   Distance : Integer;

    //IDeplacable
   Procedure Deplace;
   Procedure IDeplacable.Arret=Stop;

    //IExecutable
   Procedure Demarrage;
   Procedure Arret;

    //TChose
   Procedure ProcedureDeTChose;
   procedure Stop;
   Destructor Destroy;Override;
  end;

Identificateur non déclaré : IDeplacable

Chargez le projet interface53.
Dans le dernier exemple, nous aimerions savoir en utilisant le code suivant si IExecutable supporte (hérite de) IDeplacable
:

if Supports(MonInterface,IDeplacable) then
 begin
  writeln('IExecutable supporte IDeplacable.');
 end;

Malheureusement ce code renvoie toujours faux. Pourtant notre déclaration d'interface précise bien un héritage :

  IExecutable=interface(IDeplacable)

Revenons sur le problème de collision de nom entre des interfaces héritées, IDeplacable ne pouvait être utilisée, car inconnue dans la déclaration de la classe :

  TChose= Class(TInterfacedObject,IExecutable)

Le compilateur construit la table des interfaces d'une classe uniquement avec les interfaces déclarées dans la classe, si elle n'est pas trouvée on parcourt la table des interfaces des classes ancêtres.
L'ajout de IDeplacable dans la liste des interfaces résout notre problème.

  TChose= Class(TInterfacedObject,IDeplacable,IExecutable)

Le code suivant devenant possible :

var MonInterface : IInterface; //Permet un usage polymorphique
    MonInterfaceHeritee: IDeplacable;

begin
 MonInterface:=TChose.Create;

 if Supports(MonInterface,IDeplacable) then
  begin
   writeln('IExecutable supporte IDeplacable.');
   
   MonInterfaceHeritee:=MonInterface as IDeplacable; 
   MonInterfaceHeritee.Deplace;
   
   MonInterface:=MonInterfaceHeritee;
   IDeplacable(MonInterface).Deplace;// Cast obligatoire
  end;
 MonInterfaceHeritee:=Nil; //Appel le destructeur
 MonInterface:=Nil; //Interface déjà libérée
 readln;
end.

Pour approfondir le sujet je vous conseille la lecture du tutoriel (niveaux confirmé) sur l'organisation mémoire des classes et des interfaces par John COLIBRI.

Sur la plate-forme Win32 seules les classes peuvent implémenter des interfaces, en revanche sous la plate-forme .NET le type enregistrement (Record) peut également implémenter des interfaces.
Voici ce que donne la transformation de la classe TChose en Record :

  TChose= Record(IDeplacable)  // Implique de déclarer les méthodes de IInterface
    //TChose
   Distance : Integer;
    //IDeplacable
   Procedure Deplace;
   Procedure  Arret;
    //TChose
   Procedure ProcedureDeTChose;
   Constructor Create(ADistance: Integer);
  end;

Vous trouverez des exemples plus élaborés dans les sources de Delphi .NET :

unit Borland.Delphi.System;
...
  TDateTime = packed record(IFormattable, IComparable, IConvertible)
...

IFormattable fournit des fonctionnalités permettant de mettre en forme la valeur d'un objet dans une chaîne.

IComparable définit une méthode de comparaison généralisée qu'un type valeur ou qu'une classe implémente pour créer une méthode de comparaison spécifique au type.

IConvertible définit les méthodes qui convertissent la valeur de la référence d'implémentation ou du type valeur en un type Common Language Runtime possédant une valeur équivalente.

Pour approfondir l'aspect des interfaces notamment dans l'environnement COM consultez ce tutoriel.
Vous y trouverez d'autres informations, par exemple la délégation en utilisant la clause Implement, voir aussi Code Reuse Through Interfaces

Vous pouvez aussi consulter le chapitre 4-12 Utilisation des interfaces (page 62) du Guide du développeur Delphi 7.

Vous trouverez un exemple complet d'utilisation des interfaces dans le tutoriel intitulé « Réaliser un plug-in comportant un composant ».