Une interface est une collection de méthodes abstraites. Une classe implémente une interface, héritant ainsi les méthodes abstraites de l'interface.

Une interface n'est pas une classe. L'écriture d'une interface est similaire à l'écriture d'une classe, mais ce sont deux concepts différents. Une classe décrit les attributs et les comportements d'un objet. Une interface contient des comportements qu'une classe implémente.

Sauf si la classe qui implémente l'interface est abstraite, toutes les méthodes de l'interface doivent être définies dans la classe.

Une interface est similaire à une classe de la manière suivante:

• Une interface peut contenir n'importe quel nombre de méthodes.
• Une interface est écrite dans un fichier avec une extension .java, avec le nom de l'interface correspondant au nom du fichier.
• Le bytecode d'une interface apparaît dans un fichier .class .
• Les interfaces apparaissent dans les paquetages, et leur fichier bytecode correspondant doit être dans une structure de répertoire qui correspond au nom du package.

Cependant, une interface est différente d'une classe de plusieurs façons, y compris:

• Vous ne pouvez pas instancier une interface.
• Une interface ne contient aucun constructeur.
• Toutes les méthodes d'une interface sont abstraites.
• Une interface ne peut pas contenir de champs d'instance. Les seuls champs pouvant apparaître dans une interface doivent être déclarés statiques et finals.
• Une interface ne pas être étendue par une classe; Il est implémenté par une classe.
• Une interface peut étendre plusieurs interfaces.

Déclaration d'interfaces

Le mot clé interface est utilisé pour déclarer une interface. Voici un exemple simple pour déclarer une interface:

Exemple:

/* File name : NameOfInterface.java */
import java.lang.*;
//Any number of import statements

public interface NameOfInterface
{
   //Any number of final, static fields
   //Any number of abstract method declarations\
}

Les interfaces contiennent les propriétés suivantes:

• Une interface est implicitement abstraite. Vous n'avez pas besoin d'utiliser le mot clé abstract lors de la déclaration d'une interface.
• Chaque méthode dans une interface est également implicitement abstraite, donc le mot clé abstract n'est pas nécessaire.
• Les méthodes dans une interface sont implicitement publiques.

Exemple:

/* File name : Animal.java */
interface Animal {
   public void eat();
   public void travel();
}

Implémentation des Interfaces

Lorsqu'une classe implémente une interface, vous pouvez penser à la classe comme signature d'un contrat, en acceptant d'effectuer les comportements spécifiques de l'interface. Si une classe n'effectue pas tous les comportements de l'interface, la classe doit se déclarer abstraite.

Une classe utilise le mot clé implements pour implémenter une interface. Le mot clé implements apparaît dans la déclaration de classe suite à la partie de la déclaration d’héritage.

/* File name : 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();
   }
}

 Cela produirait le résultat suivant:

Mammal eats

Mammal travels

 Lorsque les méthodes de substitution définies dans les interfaces, il existe plusieurs règles à suivre:

• Les exceptions vérifiées ne doivent pas être déclarées sur les méthodes de mise en œuvre autres que celles déclarées par la méthode d'interface ou les sous-classes de celles déclarées par la méthode d'interface.
• La signature de la méthode d'interface et du même type ou sous-type de retour doit être maintenue lors de la substitution des méthodes.
• Une classe d'implémentation elle-même peut être abstraite et, par conséquent, les méthodes d'interface ne doivent pas être implémentées.

Lorsque les interfaces de mise en œuvre existent en plusieurs règles:

• Une classe peut implémenter plus d'une interface à la fois.
• Une classe peut étendre une seule classe, mais implémenter de nombreuses interfaces.
• Une interface peut étendre une autre interface, de la même manière qu'une classe peut étendre une autre classe.

Extension des interfaces

Une interface peut étendre une autre interface, de la même manière qu'une classe peut étendre une autre classe. Le mot clé extends est utilisé pour étendre une interface et l'interface enfant hérite des méthodes de l'interface parent.

L'interface Sports suivante est étendue par les interfaces Hockey et Football.

// Nom de fichier: Sports.java
//Filename: Sports.java
public interface Sports
{
   public void setHomeTeam(String name);
   public void setVisitingTeam(String name);
}

//Filename: Football.java

public interface Football extends Sports
{
   public void homeTeamScored(int points);
   public void visitingTeamScored(int points);
   public void endOfQuarter(int quarter);
}

//Filename: 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 a quatre méthodes, mais elle hérite de deux de Sports; Ainsi, une classe qui implémente l’interface Hockey doit mettre en œuvre les six méthodes. De même, une classe qui met en œuvre l’interface Football doit définir les trois méthodes du Football et les deux méthodes du Sports.

Extension d'interfaces multiples

Une classe Java ne peut étendre qu'une classe parent. L'héritage multiple n'est pas autorisé. Les interfaces ne sont pas des classes, cependant, et une interface peut étendre plus d'une interface parent.

Le mot clé extends est utilisé une fois, et les interfaces parent sont déclarées dans une liste séparée par des virgules.

Par exemple, si l'interface Hockey s'étendait à la fois Sports et Event, elle serait déclarée comme suit:

public interface Hockey extends Sports, Event

Marquage des Interfaces

L'utilisation la plus courante des interfaces étendues se produit lorsque l'interface parent ne contient aucune méthode. Par exemple, l'interface MouseListener dans le paquetage java.awt.event a étendu java.util.EventListener, qui est défini comme suit:

package java.util;
public interface EventListener{}

 Une interface sans méthode est appelée interface de marquage. Il existe deux objectifs de conception de base pour les interfaces de marquage:

Crée un parent commun: comme pour l'interface EventListener, étendue par des dizaines d'autres interfaces dans l'API Java, vous pouvez utiliser une interface de marquage pour créer un parent commun parmi un groupe d'interfaces. Par exemple, lorsqu'une interface étend EventListener, la JVM sait que cette interface particulière va être utilisée dans un scénario de délégation d'événement.

Ajoute un type de données à une classe: cette situation est l'origine du terme de marquage. Une classe qui implémente une interface de marquage n'a pas besoin de définir de méthodes (puisque l'interface n'en a pas), mais la classe devient un type d'interface par polymorphisme.

• ← L’Encapsulation
• Sommaire du cours
• Les Paquetages →