Interface Java

Une interface (anglais : Interface) dans le langage de programmation Java est un type abstrait, un ensemble de méthodes abstraites. Les interfaces sont généralement déclarées avec le mot-clé `interface`. Une classe hérite des méthodes abstraites d'une interface en implémentant l'interface.

Une interface n'est pas une classe. Écrire une interface est similaire à écrire une classe, mais ce sont des concepts différents. Une classe décrit les propriétés et les méthodes d'un objet. Une interface contient des méthodes qu'une classe doit implémenter.

À moins que la classe qui implémente l'interface ne soit une classe abstraite, la classe doit définir toutes les méthodes de l'interface.

Les interfaces ne peuvent pas être instanciées, mais elles peuvent être implémentées. Une classe qui implémente une interface doit implémenter toutes les méthodes décrites dans l'interface, sinon elle doit être déclarée comme une classe abstraite. De plus, en Java, les types interface peuvent être utilisés pour déclarer des variables. Elles peuvent être un pointeur null ou être liées à un objet qui implémente cette interface.

Similitudes entre les interfaces et les classes :

  • Une interface peut avoir plusieurs méthodes.
  • Les fichiers d'interface sont enregistrés dans des fichiers se terminant par .java, et le nom du fichier utilise le nom de l'interface.
  • Le fichier bytecode d'une interface est enregistré dans un fichier se terminant par .class.
  • Le fichier bytecode correspondant d'une interface doit être dans une structure de répertoires qui correspond au nom du package.

Différences entre les interfaces et les classes :

  • Les interfaces ne peuvent pas être utilisées pour instancier des objets.
  • Les interfaces n'ont pas de constructeurs.
  • Toutes les méthodes d'une interface doivent être des méthodes abstraites. Depuis Java 8, les interfaces peuvent avoir des méthodes non abstraites modifiées avec le mot-clé `default`.
  • Les interfaces ne peuvent pas contenir de variables membres, à l'exception des variables `static` et `final`.
  • Les interfaces ne sont pas héritées par les classes, mais implémentées par les classes.
  • Les interfaces prennent en charge l'héritage multiple.

Caractéristiques des interfaces

  • Toute méthode dans une interface est également implicitement abstraite. Les méthodes dans une interface sont implicitement spécifiées commepublic abstract(Seul `public abstract` ; tout autre modificateur provoquera une erreur.)
  • Les interfaces peuvent contenir des variables, mais les variables dans une interface sont implicitement spécifiées comme des variablespublic static final(et uniquement `public` ; l'utilisation de `private` provoquera une erreur de compilation).
  • Les méthodes d'une interface ne peuvent pas être implémentées dans l'interface ; elles ne peuvent être implémentées que par la classe qui implémente l'interface.

Différence entre les classes abstraites et les interfaces

  • 1. Les méthodes d'une classe abstraite peuvent avoir un corps de méthode, c'est-à-dire qu'elles peuvent implémenter la fonctionnalité spécifique de la méthode, mais les méthodes d'une interface ne le peuvent pas.
  • 2. Les variables membres d'une classe abstraite peuvent être de types variés, tandis que les variables membres d'une interface ne peuvent être que de typepublic static final.
  • 3. Les interfaces ne peuvent pas contenir de blocs de code statiques et de méthodes statiques (méthodes modifiées avec `static`), mais les classes abstraites peuvent avoir des blocs de code statiques et des méthodes statiques.
  • 4. Une classe ne peut hériter que d'une seule classe abstraite, mais une classe peut implémenter plusieurs interfaces.

Remarque: depuis JDK 1.8, les interfaces peuvent avoir des méthodes statiques et des corps de méthode.

Remarque: Depuis le JDK 1.8, les interfaces sont autorisées à contenir des méthodes avec des implémentations concrètes, appelées « méthodes par défaut ». Les méthodes par défaut sont modifiées par le mot-clé `default`. Pour plus d’informations, voirMéthodes par défaut de Java 8。

Remarque: Depuis le JDK 1.9, les méthodes sont autorisées à être définies comme privées, afin que du code réutilisable n’expose pas de méthodes. Pour plus d’informations, voirMéthodes privées d’interface de Java 9。

Déclaration des interfaces

La syntaxe de déclaration d’une interface est la suivante :

[visibilité] interfacenom d’interface[extendsautres noms d’interface] { //déclarer des variables //méthodes abstraites }

Le mot-clé `interface` est utilisé pour déclarer une interface. Ci-dessous un exemple simple de déclaration d’interface.

Code du fichier NameOfInterface.java :

/*Nom du fichier : NameOfInterface.java*/ import java.lang.*; //Importer des packages public interface NameOfInterface { //Champs final, static de tout type //Méthodes abstraites }
Les interfaces ont les caractéristiques suivantes :
  • Les interfaces sont implicitement abstraites. Lors de la déclaration d'une interface, il n'est pas nécessaire d'utiliserabstractle mot-clé.
  • Chaque méthode d'une interface est également implicitement abstraite. Lors de la déclaration, vous n'avez pas non plus besoin d'utiliserabstractle mot-clé.
  • Les méthodes d'une interface sont toutes publiques.

Exemple

Code du fichier Animal.java :

/*Nom du fichier : Animal.java*/ interface Animal { public void eat(); public void travel(); }

Implémentation des interfaces

Lorsqu'une classe implémente une interface, la classe doit implémenter toutes les méthodes de l'interface. Sinon, la classe doit être déclarée comme une classe abstraite.

Une classe utilise le mot-clé `implements` pour implémenter une interface. Dans une déclaration de classe, le mot-clé `implements` est placé après la déclaration `class`.

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

Syntaxe d'interface :

...implementsnom d'interface[, autres noms d'interface, autres noms d'interface..., ...] ...

Exemple

Code du fichier MammalInt.java :

/*Nom du fichier : MammalInt.java*/ public class MammalInt implements Animal{ public void eat(){ System.out.println("Mammal eats"); } public void travel(){ System.out.println("Mammal travels"); } public int noOfLegs(){ return 0; } public static void main(String args[]){ MammalInt m = new MammalInt(); m.eat(); m.travel(); } }

Le résultat de compilation et d'exécution de l'exemple ci-dessus est le suivant :

Mammal eats
Mammal travels

Lorsque vous redéfinissez des méthodes déclarées dans une interface, vous devez faire attention aux règles suivantes :

  • Lorsqu'une classe implémente une méthode d'interface, elle ne peut pas lever d'exception obligatoire ; l'exception obligatoire ne peut être levée que dans l'interface, ou dans la classe abstraite qui hérite de l'interface.
  • Lors de la redéfinition d'une méthode, la classe doit conserver le même nom de méthode et doit conserver le même type de retour ou un type compatible.
  • Si la classe qui implémente l'interface est une classe abstraite, il n'est pas nécessaire d'implémenter les méthodes de l'interface.

Lors de l'implémentation d'une interface, vous devez également faire attention à certaines règles :

  • Une classe peut implémenter plusieurs interfaces en même temps.
  • Une classe ne peut hériter que d'une seule classe, mais peut implémenter plusieurs interfaces.
  • Une interface peut hériter d'une autre interface, ce qui est similaire à l'héritage entre classes.

Héritage des interfaces

Une interface peut hériter d'une autre interface, ce qui est similaire à l'héritage entre classes. L'héritage d'interfaces utilise le mot-clé `extends`, et une sous-interface hérite des méthodes de l'interface parente.

L'interface Sports suivante est héritée par les interfaces Hockey et Football :

//Nom du fichier : Sports.java public interface Sports { public void setHomeTeam(String name); public void setVisitingTeam(String name); } //Nom du fichier : Football.java public interface Football extends Sports { public void homeTeamScored(int points); public void visitingTeamScored(int points); public void endOfQuarter(int quarter); } //Nom du fichier : Hockey.java public interface Hockey extends Sports { public void homeGoalScored(); public void visitingGoalScored(); public void endOfPeriod(int period); public void overtimePeriod(int ot); }

L'interface Hockey déclare quatre méthodes par elle-même et hérite de deux méthodes de l'interface Sports. De cette façon, une classe qui implémente l'interface Hockey doit implémenter six méthodes.

De même, une classe qui implémente l'interface Football doit implémenter cinq méthodes, dont deux proviennent de l'interface Sports.

Héritage multiple d'interfaces

En Java, l'héritage multiple de classes est illégal, mais les interfaces autorisent l'héritage multiple.

Dans l'héritage multiple d'interfaces, le mot-clé `extends` ne doit être utilisé qu'une seule fois, suivi des interfaces héritées. Comme indiqué ci-dessous :

public interface Hockey extends Sports, Événement

Le fragment de programme ci-dessus est une sous-interface légalement définie. Contrairement aux classes, les interfaces autorisent l'héritage multiple, et Sports et Event peuvent définir ou hériter des mêmes méthodes.

Interfaces marqueurs

L'interface marqueur la plus couramment utilisée est une interface qui ne contient aucune méthode.

Une interface marqueur est une interface sans méthodes ni propriétés. Elle indique simplement que sa classe appartient à un type spécifique, afin que d'autres codes puissent tester et autoriser certaines choses à être faites.

Objectif d'une interface marqueur : pour le dire simplement et de manière imagée, il s'agit de mettre une étiquette (un tampon) sur un objet, ce qui donne à l'objet certains privilèges.

Par exemple : l'interface java.util.EventListener, qui est héritée par l'interface MouseListener du paquet java.awt.event, est définie comme suit :

package java.util; public interface EventListener {}

Une interface sans aucune méthode est appelée interface marqueur. Les interfaces marqueurs sont principalement utilisées pour les deux objectifs suivants :

  • Établir une interface parente commune :

    Tout comme l'interface EventListener, qui est une API Java étendue par des dizaines d'autres interfaces, vous pouvez utiliser une interface marqueur pour établir une interface parente pour un groupe d'interfaces. Par exemple : lorsqu'une interface hérite de l'interface EventListener, la machine virtuelle Java (JVM) sait que cette interface sera utilisée dans un schéma de délégation d'événements.

  • Ajouter un type de données à une classe :

    Cette situation est l'objectif initial des interfaces marqueurs. Une classe qui implémente une interface marqueur n'a pas besoin de définir de méthodes d'interface (car une interface marqueur n'a tout simplement aucune méthode), mais la classe devient un type d'interface grâce au polymorphisme.

Autres extensions