Motifs d'utilisation des interfaces
Les interfaces vous permettent de définir comment un programme s'adressera à une ou plusieurs classes. Dans une interface, vous pouvez définir des méthodes, des attributs, des types et des constantes, comme vous le feriez dans une classe. Ces composants forment une description de la manière dont un programme client peut interagir avec les objets correspondants. Cependant, une interface ne peut pas être instanciée et ne contient aucune implémentation de ses méthodes. Pour que le concept fonctionne, nous avons également besoin d'une ou plusieurs classes qui implémentent l'interface. Cela signifie qu'ils incluent l'interface dans leur propre déclaration de classe et que les composants déclarés dans l'interface font partie de la classe elle-même. Si l'interface contient des déclarations de méthode, la classe qui implémente l'interface doit également fournir une implémentation de ces méthodes.
Les interfaces ont deux utilisations importantes :
Fournir une approche unifiée à différentes classes : si vous avez des classes qui ne sont pas liées par héritage, mais qui doivent toujours fournir des services communs à leurs utilisateurs, vous pouvez définir les services communs dans une interface. Cela garantit que chaque classe fournit une méthode avec le même nom et la même signature pour effectuer une tâche particulière. Les programmes qui utilisent les classes ont alors un seul moyen d'appeler des fonctions particulières quelle que soit la classe qu'ils adressent réellement.
Approche simplifiée d'une classe complexe : comme vous le verrez plus loin, les interfaces fournissent une vue restreinte d'un objet. Cela vous permet d'exposer un ensemble particulier de méthodes à un programme qui utilisera une classe particulière sur la base des fonctions dont le programme a réellement besoin.
Regardez cet exemple pour savoir comment fonctionne une interface.
Définition d'interface
La définition d'une interface est très similaire à la section de définition d'une classe. Cependant, comme une interface n'a pas d'implémentation, il n'y a pas d'option DEFINITION dans l'instruction INTERFACE. La deuxième différence majeure est qu'il n'y a pas de sections de visibilité dans une interface, car tous les composants d'une interface sont publics. Les interfaces sont utiles en raison de leur interaction avec d'autres classes, donc avoir des composants non publics n'aurait aucun sens.
Dans la définition d'interface, vous pouvez utiliser des types, des attributs, des constantes et des méthodes, et les composantes d'instance et statiques sont autorisées. N'oubliez pas que les méthodes d'interface ont une définition, mais pas d'implémentation. Elle sera fournie par la classe d'implémentation.
À bien des égards, les interfaces sont similaires aux superclasses abstraites. Ils fournissent une technique utile pour les cas dans lesquels vous devez définir des membres communs pour les classes sans qu'il y ait de cas d'héritage, en d'autres termes, il n'y a pas de relation "est une" claire.
Implémentation de l'interface
Pour implémenter une interface dans une classe, vous utilisez l'instruction INTERFACES. Comme tous les composants de l'interface sont publics et que vous ne pouvez pas modifier la visibilité d'un composant existant, vous devez inclure l'interface dans la section publique de la classe.
Dès que vous avez écrit l'instruction INTERFACES, votre programme est syntaxiquement incorrect. En effet, l'interface contient une méthode que vous n'avez pas encore implémentée. Vous pouvez utiliser un correctif rapide (Ctrl + 1) pour ajouter l'implémentation de méthode à votre classe.
Lorsque vous déclarez une interface dans une classe, vous devez implémenter toutes ses méthodes.
Dans l'implémentation de votre classe, vous devez implémenter toutes les méthodes déclarées dans l'interface. Lorsque vous nommez la méthode dans l'implémentation, vous devez utiliser le nom complet, qui se compose du nom de l'interface et du nom de la méthode joints par un tilde. En effet, il n'y a aucune garantie que le nom de la méthode lui-même est sans ambiguïté ; n'oubliez pas que les noms de composants ne doivent être uniques que dans la classe ou l'interface dans laquelle ils sont déclarés. Par conséquent, une classe peut déclarer une méthode appelée get_partner_Attributes ainsi que l'interface lif_partner.