Delphi et les interfaces d'objetDate de publication : 01/09/2005
Par
Pascal Jankowski (Contributions)
En quelques mots, nous pouvons brièvement définir une interface objet ou interface
comme la signature d'un objet, c'est à dire "ce qu'il fait" mais pas "comment il le fait".
Ainsi plusieurs implémentations peuvent s'abonner à la même interface et l'implémentation d'un objet
peut s'abonner à plusieurs interfaces. I. Notion d'interface et intérêts A. Principe d'encapsulation, abstraction. B. Partage d'interfaces entre des classes, polymorphisme C. Distribuer des objets dans un environnement réseau D. Simuler le comportement de l'héritage multiple E. Conclusion II. Interface - Mise en oeuvre A. Définir une interface B. Implémenter une interface 1. Clauses de résolution de méthode 2. Modification de l'implémentation héritée 3. Implémentation des interfaces par délégation a. Délégation à une propriété de type interface b. Délégation à une propriété de type classe C. Utiliser une interface D. Références d'interface E. Dérivation d'une interface III. Interface IUnknown IV. Identification d'une interface - GUID V. Conventions d'appel VI. Les objets automation A. Les interfaces de répartition - dispinterface B. Comment accéder aux objets automation C. Les interfaces doubles I. Notion d'interface et intérêts
Une interface définit des méthodes qui peuvent être implémentées par une classe.
Elles sont déclarées comme des classes mais ne peuvent être directement instanciées
et n'ont pas leurs propres définitions de méthodes. Cette responsabilité revient aux
classes gérant une interface en fournissant l'implémentation des méthodes de l'interface. Les interfaces proposent certains avantages de l'héritage multiple sans en avoir la complexité sémantique. Elles jouent également un rôle important dans l'utilisation des modèles d'objets distribués comme COM, CORBA et SOAP. Un atout supplémentaire réside dans le fait que les interfaces concues avec Delphi peuvent interopérer avec les objets écrits dans d'autres langages. A. Principe d'encapsulation, abstraction.
L'encapsulation est un mécanisme qui consiste à rassembler les données et les méthodes au sein d'une structure en
cachant l'implémentation de la classe. Cela revient à empêcher l'accés aux données par tout autre moyen que les
services proposés. Ainsi, cela garantit l'intégrité des données contenues dans la classe. Il est possible de mettre en oeuvre une protection plus importante encore en faisant appel à une interface qui jouera le rôle d'intermédiaire entre une application et une classe. Seules les méthodes définies dans l'interface et son implémentation dans la classe protégée pourront être invoquées par l'application. Les interfaces sollicitent ainsi le principe d'abstraction.  B. Partage d'interfaces entre des classes, polymorphisme
Il arrive bien souvent que dans une modélisation objet, nous souhaitions que deux objets indépendants
(ne descendant pas d'une classe commune), utilisent une même méthode. L'utilisation d'une interface
permet alors de résoudre ce problème. En effet deux classes peuvent partager la même interface sans
pour autant descendre de la même classe de base. Ainsi, un appel polymorphique de la même méthode est
réalisable.
Dans le schéma ci-dessus, que les deux classes TCercle et TCarre aient ou non un ancêtre commun,
elles disposent d'une méthode paint. Il est possible d'obtenir le même résultat en faisant dériver TCercle et TSquare d'une même classe TFigure qui implémente la méthode virtuelle Paint. Dans ce cas, TCercle et TSquare doivent surcharger la méthode Paint. L'interface IPaint est alors substituée par TFigure comme schématisé ci-dessous. 
C. Distribuer des objets dans un environnement réseau
La technologie des objets distribués permet de rendre accessible des objets à tout ordinateur
connecté au réseau. Le principe de cette technologie est de décrire les fonctionalités des
objets "distribuables" par le biais d'une interface. C'est le moyen de mettre à disposition du client
le service fourni par l'objet, sans lui donner les détails de l'implémentation de celui-ci.
Cela permet alors d'utiliser des objets distants comme s'ils résidaient localement sur votre station.
Notons, de façon générale, qu'utiliser les interfaces permet de conserver la compatibilité entre les objets et le code du client.
Il n'est pas nécessaire de recompiler les clients car l'implémentation des interfaces est cachée (les méthodes
et leurs propriétés restent inchangées). Le développeur peut modifier l'implémentation afin d'améliorer les
performances, ou pour d'autres motifs, sans perturber le code client qui dépend de cette interface. Dans un autre cas de figure, un objet distribué initialement prévu pour une application client peut être récupéré et utilisé par un second applicatif client, cela favorise ainsi la réutilisation.
D. Simuler le comportement de l'héritage multiple
Dans certaines situations, il peut s'avérer intéressant d'élargir le mécanisme d'héritage pour
qu'une classe hérite directement de plusieurs autres classes. Elle hérite alors de l'union des
champs et des méthodes de ses ancêtres. On parle alors d'héritage multiple. L'héritage multiple est interdit pour les classes Delphi afin d'éviter les conflits qui se produisent lorsqu'une classe hérite de deux méthodes portant le même identificateur (collision). Citons par exemple, le cas de l'héritage triangulaire, où une classe TD hérite à la fois de deux classes TB et TC qui elles-mêmes héritent d'une classe TA. Comment se comporte alors une méthode TD héritée de TA ? 
Les interfaces permettent de résoudre simplement de tels conflits car elles obligent les classes
à implémenter toutes les méthodes décrites dans l'interface. D'autre part, une classe peut supporter plusieurs interfaces, comme si elle "héritait" de plusieurs classes, ce qui simule le comportement de l'héritage multiple. E. Conclusion
A l'issue de cette première approche, nous voyons qu'une interface est un ensemble de "prototypes" de méthodes.
Une interface permet de procurer le "polymorphisme de méthodes" et simule élégamment l'héritage multiple.
Par ailleurs, leur utilisation permet de faciliter la maintenance et l'évolution du code, tout en favorisant sa réutilisation.
II. Interface - Mise en oeuvreA. Définir une interfaceB. Implémenter une interface1. Clauses de résolution de méthode2. Modification de l'implémentation héritée3. Implémentation des interfaces par délégationa. Délégation à une propriété de type interfaceb. Délégation à une propriété de type classeC. Utiliser une interfaceD. Références d'interfaceE. Dérivation d'une interfaceIII. Interface IUnknownIV. Identification d'une interface - GUIDV. Conventions d'appelVI. Les objets automationA. Les interfaces de répartition - dispinterfaceB. Comment accéder aux objets automationC. Les interfaces doubles |
Copyright © 2005 Pascal Jankowski. Aucune reproduction, même partielle, ne peut être faite de ce site ni de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
