Interface (Java)

Une interface dans le langage de programmation Java est un type abstrait utilisé pour déclarer un comportement que les classes doivent implémenter. Elles sont similaires aux protocoles . Les interfaces sont déclarées à l'aide du interface mot-clé et ne peuvent contenir que des déclarations de signature de méthode et de constante (déclarations de variables déclarées comme étant à la fois staticet final). Toutes les méthodes d'une interface ne contiennent pas d'implémentation (corps de méthode) à partir de toutes les versions antérieures à Java 8. À partir de Java 8, les méthodes default et static peuvent avoir une implémentation dans la interfacedéfinition. Puis, dans Java 9, les méthodes privateet private staticont été ajoutées. À l'heure actuelle, une interface Java peut avoir jusqu'à six types différents.

Les interfaces ne peuvent pas être instanciées , mais implémentées. Une classe qui implémente une interface doit implémenter toutes les méthodes non par défaut décrites dans l'interface, ou être une classe abstraite . Les références d'objet en Java peuvent être spécifiées comme étant d'un type d'interface ; dans chaque cas, elles doivent être null ou être liées à un objet qui implémente l'interface.

L'un des avantages de l'utilisation d'interfaces est qu'elles simulent l'héritage multiple . Toutes les classes en Java doivent avoir exactement une classe de base , la seule exception étant java.lang.Object(la classe racine du système de types Java ) ; l'héritage multiple de classes n'est pas autorisé. Cependant, une interface peut hériter de plusieurs interfaces et une classe peut implémenter plusieurs interfaces.

Les interfaces sont utilisées pour encoder les similitudes que partagent les classes de différents types, mais ne constituent pas nécessairement une relation de classe. Par exemple, un humain et un perroquet peuvent tous deux siffler ; cependant, il ne serait pas logique de représenter Humans et Parrots comme des sous-classes d'une Whistlerclasse. Il s'agirait plutôt probablement de sous-classes d'une Animalclasse (probablement avec des classes intermédiaires), mais les deux implémenteraient l' Whistlerinterface.

Une autre utilisation des interfaces est de pouvoir utiliser un objet sans connaître son type de classe, mais seulement qu'il implémente une certaine interface. Par exemple, si quelqu'un est dérangé par un sifflement, il se peut qu'il ne sache pas s'il s'agit d'un humain ou d'un perroquet, car tout ce qui peut être déterminé est qu'un siffleur siffle. L'appel whistler.whistle()appellera la méthode implémentée whistlede object whistlerquelle que soit sa classe, à condition qu'elle implémente Whistler. Dans un exemple plus pratique, un algorithme de tri peut s'attendre à un objet de type Comparable. Ainsi, sans connaître le type spécifique, il sait que les objets de ce type peuvent d'une manière ou d'une autre être triés.

Par exemple:

interface 
Bounceable { double pi = 3.1415 ; void setBounce (); // Notez le point-virgule // Les méthodes d'interface sont publiques, abstraites et jamais finales. // Considérez-les uniquement comme des prototypes ; aucune implémentation n'est autorisée. }

Une interface :

• déclare uniquement les en-têtes de méthode et les constantes publiques.
• ne peut pas être instancié.
• peut être implémenté par une classe.
• ne peut pas étendre une classe.
• peut étendre plusieurs autres interfaces.

Les interfaces sont définies avec la syntaxe suivante (à comparer avec la définition de classe de Java ) :

[ visibilité ] interface InterfaceName [étend d'autres interfaces ] { déclarations de constantes déclarations 
de méthodes abstraites 
déclarations de méthodes statiques } 

Exemple : l’interface publique Interface1 étend Interface2 ;

Le corps de l'interface contient des méthodes abstraites , mais comme toutes les méthodes d'une interface sont, par définition, abstraites, le abstractmot clé n'est pas obligatoire. Comme l'interface spécifie un ensemble de comportements exposés, toutes les méthodes sont implicitement public.

Ainsi, une interface simple peut être

interface publique Predator { booléen chasePrey ( Prey p ); void eatPrey ( Prey p ); }

Les déclarations de type de membre dans une interface sont implicitement statiques, finales et publiques, mais sinon elles peuvent être n'importe quel type de classe ou d'interface.

La syntaxe d'implémentation d'une interface utilise cette formule :

... implémente InterfaceName [, une autre interface , une autre , ...] ... 

Les classes peuvent implémenter une interface. Par exemple :

la classe publique Lion implémente Predator {
@Override 
public boolean chasePrey ( Prey p ) { // Programmation pour chasser une proie p (spécifiquement pour un lion) }
@Override 
public void eatPrey ( Prey p ) { // Programmation pour manger une proie p (spécifiquement pour un lion) } }

Si une classe implémente une interface et n'implémente pas toutes ses méthodes, elle doit être marquée comme abstract. Si une classe est abstraite, l'une de ses sous-classes est censée implémenter ses méthodes non implémentées, mais si l'une des sous-classes de la classe abstraite n'implémente pas toutes les méthodes d'interface, la sous-classe elle-même doit être à nouveau marquée comme abstract.

Les classes peuvent implémenter plusieurs interfaces :

la classe publique Frog implémente Predator , Prey { ... }

Les interfaces peuvent partager des méthodes de classe communes :

classe 
Animal implémente LikesFood , LikesWater { booléen likes () { renvoie true ; } }

Cependant, une classe donnée ne peut pas implémenter plusieurs fois la même interface ou une interface similaire :

classe 
Animal implémente Shares < Boolean > , Shares < Integer > ... // Erreur : interface répétée

Les interfaces sont couramment utilisées dans le langage Java pour les rappels car Java ne permet pas l'héritage multiple de classes, ni le passage de méthodes (procédures) en tant qu'arguments. Par conséquent, afin de passer une méthode en tant que paramètre à une méthode cible, la pratique actuelle consiste à définir et à passer une référence à une interface comme moyen de fournir la signature et l'adresse de la méthode paramètre à la méthode cible plutôt que de définir plusieurs variantes de la méthode cible pour s'adapter à chaque classe appelante possible.

Les interfaces peuvent étendre plusieurs autres interfaces, en utilisant la même formule que celle décrite ci-dessous. Par exemple,

interface publique VenomousPredator étend Predator , Venomous { // Corps de l'interface }

est légal et définit une sous-interface. Il permet l'héritage multiple, contrairement aux classes. Predatoret Venomouspeut éventuellement définir ou hériter de méthodes avec la même signature, par exemple kill(Prey p). Lorsqu'une classe implémente, VenomousPredatorelle implémentera les deux méthodes simultanément.

Certaines interfaces Java courantes sont :

• Comparablepossède la méthode compareTo, qui est utilisée pour décrire deux objets comme égaux ou pour indiquer que l'un est supérieur à l'autre. Les génériques permettent d'implémenter des classes pour spécifier quelles instances de classe peuvent leur être comparées.
• Serializableest une interface de marqueur sans méthodes ni champs - elle a un corps vide. Elle est utilisée pour indiquer qu'une classe peut être sérialisée . Sa Javadoc décrit comment elle doit fonctionner, bien que rien ne soit imposé par programmation