Interface (informatique)

Si ce bandeau n'est plus pertinent, retirez-le. Cliquez ici pour en savoir plus.

Cet article ne cite pas suffisamment ses sources (août 2022).

Si vous disposez d'ouvrages ou d'articles de référence ou si vous connaissez des sites web de qualité traitant du thème abordé ici, merci de compléter l'article en donnant les références utiles à sa vérifiabilité et en les liant à la section « Notes et références ».

En pratique : Quelles sources sont attendues ? Comment ajouter mes sources ?

Une interface définit la frontière de communication entre deux entités, comme des éléments de logiciel, des composants de matériel informatique, ou un utilisateur. Elle se réfère généralement à une image abstraite qu'une entité fournit d'elle-même à l'extérieur. Cela permet de distinguer les méthodes de communication avec l'extérieur et les opérations internes, et autorise à modifier les opérations internes sans affecter la façon dont les entités externes interagissent avec elle, en même temps qu'elle en fournit des abstractions multiples. On appelle aussi interfaces des dispositifs fournissant un moyen de traduction entre des entités qui n'utilisent pas le même langage, comme entre un être humain et un ordinateur. Étant donné que ces interfaces réalisent des traductions et des adaptations, elles entraînent des coûts de développement supplémentaires par rapport à des communications directes.

Variétés :

Une interface humain-machine permet des échanges entre un humain et une machine ;
Une interface de programmation permet des échanges entre plusieurs logiciels ;
L’interface qui est présentée à l’utilisateur est nommée interface utilisateur ;
Les interfaces entre des composants de matériel informatique sont des interfaces physiques.

Cet article traite des interfaces logicielles qui existent entre différents composants logiciels et fournissent un mode de programmation par lequel ces composants peuvent communiquer.^[pas clair]

Interfaces en pratique[modifier | modifier le code]

Un élément de logiciel fournit l'accès aux ressources informatiques (comme la mémoire, le processeur, le stockage, etc.) par son système informatique sous-jacent ; laisser ces ressources accessibles par d'autres logiciels peut avoir des ramifications majeures — quelquefois désastreuses — pour ses fonctionnalités et sa stabilité. Un principe clé de conception est d'interdire l'accès à toutes les ressources par défaut, en autorisant l'accès seulement à travers des points d'entrée bien définis, i.e. les interfaces (voir encapsulation).

Les types d'accès que les interfaces fournissent entre les composants logiciels peuvent inclure : constantes, types de données, types de procédures, exception spécifications et signatures de méthodes. Dans certains cas, il peut être utile de définir dans l'interface des variables. On y spécifie souvent aussi la fonctionnalité des procédures et des méthodes incluses, soit par des commentaires ou (dans certains langages expérimentaux) par des assertions formelles logiques.

L'interface d'un module logiciel $A$ est intentionnellement gardée rigoureusement séparée de l'implémentation de celui-ci. Ce dernier contient le code proprement dit des procédures et méthodes décrites dans l'interface (aux côtés du code des variables et procédures « privées »). Un module logiciel $B$ qui utilise $A$ (autrement dit un client de A) n'y accède pas directement, il y accède uniquement par le travers de l'interface de $A$ . L'utilisation d'interfaces offre ainsi l'avantage qu'un remplacement d'implémentation de $A$ par une autre, répondant aux mêmes spécifications de l'interface, ne peut causer de défaillance d'un module client $B$ — si tant est bien sûr que son utilisation de $A$ se conforme aux spécifications de l'interface (voir aussi principe de substitution de Liskov).

Utilisation des interfaces[modifier | modifier le code]

Le concept d'interface est la pierre angulaire de la programmation modulaire, un précurseur et un élément standard de la programmation orientée objet. Dans la programmation orientée objet, l'interface d'un objet consiste en un ensemble de méthodes que l'objet doit suivre. C'est le « contrat de service » du composant. Les variables d'instance de l'objet ne font pas partie de l'interface - on y accède spécifiquement via des accesseurs.

Certains langages orientés-objet nécessitent de définir séparément l'interface et l'implémentation. Par exemple, en Objective-C, l'interface est définie dans un fichier d'en-tête et l'implémentation dans un fichier source. Par exemple, de par le typage et le chargement dynamique d'Objective-C, il est possible d'envoyer un message à n'importe quel objet, l'interface spécifiant quelle méthode doit y répondre (parmi les méthodes de la classe de l'objet et les méthodes des classes parentes).

Les interfaces sont historiquement dérivées des fichiers d'entête C avec un contexte et un contenu restreints, devenant une partie de la sémantique du langage (par opposition aux fonctionnalités du préprocesseur C).

Le langage Java adopte une approche différente du concept d'interface qui existe normalement dans d'autres langages orientés objet (ie., que l'interface spécifiée est l'interface avec la classe), en ce qu'une interface spécifie un ensemble de méthodes qui implémente des fonctionnalités spécifiques, communes à un ensemble de classes. Voir protocole (programmation orientée objet).

Certains langages de programmation (e.g. D, Java, Logtalk) autorisent la définition de hiérarchies d'interface. Ceci autorise une définition de, par exemple, à la fois la version minimale et étendue d'une interface.

Certains langages de programmation (e.g. Logtalk) supportent une implémentation privée et protégée d'une interface. Ainsi, les méthodes (publiques) déclarées dans une interface peuvent facilement devenir des méthodes privées ou protégées d'une classe qui implémente l'interface.

Le langage Eiffel inclut dans l'interface d'une classe son invariant et la pré- et postconditions des méthodes de la classe. Ceci est essentiel à la méthodologie de conception par contrat, et peut être considéré comme une extension des conditions imposées par les types d'arguments. Ces règles peuvent être spécifiées dans l'implémentation d'une classe ou dans un ancêtre qui peut quitter les méthodes non implémentées.

Ces règles peuvent être extraites dans l'environnement de développement par l'analyseur syntaxique afin de fournir à l'utilisateur une vue de l'interface de ces classes. Au niveau de la compilation, elles permettent de définir des assertions c'est-à-dire des conditions déclenchant des exceptions ; on parle de contrat de la méthode.

Exemple de contrat d'une fonction « division(numérateur, diviseur) » recevant numérateur et diviseur en paramètres : si le diviseur est égal à zéro, je déclenche une assertion sinon j'effectue une division.

Les assertions peuvent avoir des comportements différents selon le mode debug ou release : généralement en mode debug l'application s'arrête ce qui permet de repérer l'erreur contrairement au mode release qui favorise la continuité de service.

Dans l'exemple de la division, l'assertion provoquerait en mode debug l'arrêt du programme et en release renverrait la valeur zéro.

Le langage assure aussi que les classes dérivées obéissent aux contrats de leurs ancêtres.

Langages qui fournissent des facilités d'interfaçage[modifier | modifier le code]

Certains langages de programmation ont différentes méthodologies pour permettre la réalisation d'interfaces. En général, tout langage de programmation peut implémenter une interface, mais les langages de programmation suivants offrent des facilités d'interfaçage spécifiques d'une façon ou d'une autre :

ActionScript in Flash, Ada, C#, C (langage), D, Delphi, Eiffel, Java, Logtalk, Mesa, ML, Modula, Modula-2, Modula-3, Oberon, Objective-C, PHP, Ocaml, Python, REALbasic, Unified Modeling Language, Visual Basic

Interfaces de programmation[modifier | modifier le code]

Une interface de programmation (Application Programming Interface ou API) définit les fonctions publiées par une bibliothèque logicielle, utilisables par les applications clientes.

En science de la communication[modifier | modifier le code]

En sciences de l'information et de la communication, l’interface est un empilement de couches, depuis le support physique de l'information jusqu'à sa diffusion dans la société.

En électronique[modifier | modifier le code]

Dans le cas de l’électronique, il est utile de détailler la couche physique précédemment décrite et commode de réunir les suivantes. L’interface peut alors être définie par quatre couches :

Physique : définition des broches de connexion (nombre, disposition), configuration mécanique des connecteurs (NB : cette couche peut être absente de certaines définitions relâchées d’une interface)
Électrique : mode de pilotage (tension/courant) des signaux, niveaux de tension (ou de courant) définissant les états de chaque signal, vitesses minimale et maximale de commutation, temps d’établissement et/ou de maintien (par rapport à d’autres signaux), etc.
Logique : nom des signaux et alimentations véhiculés par les broches du/des connecteur(s), sens de distribution (ou éventuellement bidirectionnalité)
Protocolaire : rapport des signaux entre eux, signification des successions d’événements sur un signal ou un groupe de signaux, interdits, etc.

Notes et références[modifier | modifier le code]

Voir aussi[modifier | modifier le code]

Articles connexes[modifier | modifier le code]