Java-Interfaces

Une interface est un type de référence en Java. C'est similaire à la classe. C'est une collection de méthodes abstraites. Une classe implémente une interface, héritant ainsi des méthodes abstraites de l'interface.

Outre les méthodes abstraites, une interface peut également contenir des constantes, des méthodes par défaut, des méthodes statiques et des types imbriqués. Les corps de méthode existent uniquement pour les méthodes par défaut et les méthodes statiques.

L'écriture d'une interface est similaire à l'écriture d'une classe. Mais une classe décrit les attributs et les comportements d'un objet. Et 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 un .java extension, avec le nom de l'interface correspondant au nom du fichier.

• Le byte code d'une interface apparaît dans un .class fichier.

• Les interfaces apparaissent dans les packages et leur fichier de bytecode correspondant doit se trouver dans une structure de répertoires correspondant au nom du package.

Cependant, une interface est différente d'une classe de plusieurs manières, notamment −

• 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 à la fois statique et final.

• Une interface n'est pas étendue par une classe; il est implémenté par une classe.

• Une interface peut étendre plusieurs interfaces.

Déclarer des interfaces

L'interface mot clé est utilisé pour déclarer une interface. Voici un exemple simple pour déclarer une interface −

Exemple

Voici un exemple d'interface −

/* 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 ont les propriétés suivantes −

• Une interface est implicitement abstraite. Vous n'avez pas besoin d'utiliser le résumé mot clé lors de la déclaration d'une interface.

• Chaque méthode dans une interface est aussi implicitement abstraite, donc le mot-clé abstract n'est pas nécessaire.

• Les méthodes d'une interface sont implicitement publiques.

Exemple

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

Mise en œuvre d'interfaces

Lorsqu'une classe implémente une interface, vous pouvez considérer la classe comme signant un contrat, acceptant d'exécuter les comportements spécifiques de l'interface. Si une classe n'exécute pas tous les comportements de l'interface, la classe doit se déclarer abstraite.

Une classe utilise les outils mot-clé pour implémenter une interface. Le mot-clé implements apparaît dans la déclaration de classe après la partie extend de la déclaration.

Exemple

/* 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 produira le résultat suivant −

Sortie

Mammal eats
Mammal travels

Lors du remplacement des méthodes définies dans les interfaces, il y a plusieurs règles à suivre −

• Les exceptions cochées ne doivent pas être déclarées sur des méthodes d'implémentation autres que celles déclarées par la méthode d'interface ou des sous-classes de celles déclarées par la méthode d'interface.

• La signature de la méthode d'interface et le même type ou sous-type de retour doivent être conservés lors du remplacement des méthodes.

• Une classe d'implémentation elle-même peut être abstraite et si c'est le cas, les méthodes d'interface n'ont pas besoin d'être implémentées.

Lors de la mise en œuvre des interfaces, il existe plusieurs règles −

• Une classe peut implémenter plusieurs interfaces à la fois.

• Une classe ne peut étendre qu'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.

Étendre les interfaces

Une interface peut étendre une autre interface de la même manière qu'une classe peut étendre une autre classe. Le s'étend mot-clé 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.

Exemple

// 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 en hérite deux de Sports ; ainsi, une classe qui implémente Hockey doit implémenter les six méthodes. De même, une classe qui implémente Football doit définir les trois méthodes de Football et les deux méthodes de Sports.

Étendre plusieurs interfaces

Une classe Java ne peut étendre qu'une seule classe parente. L'héritage multiple n'est pas autorisé. Cependant, les interfaces ne sont pas des classes et une interface peut étendre plusieurs interfaces parentes.

Le mot clé extend est utilisé une seule fois et les interfaces parentes sont déclarées dans une liste séparée par des virgules.

Par exemple, si l'interface Hockey étendait à la fois Sports et Événement, elle serait déclarée comme −

Exemple

public interface Hockey extends Sports, Event

Interfaces de balisage

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

Exemple

package java.util;
public interface EventListener
{}

Une interface sans méthode est appelée tagging interface. Il existe deux objectifs de conception de base pour le balisage des interfaces −

Crée un parent commun − Comme avec l'interface EventListener, qui est étendue par des dizaines d'autres interfaces dans l'API Java, vous pouvez utiliser une interface de balisage 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énements.

Ajoute un type de données à une classe − C'est de cette situation que vient le 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.