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.

À moins que la classe qui implémente l'interface soit abstraite, toutes les méthodes de l'interface doivent être définies dans la classe.

Une interface est similaire à une classe des manières suivantes -

  • 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 code d'octet d'une interface apparaît dans un .class fichier.

  • Les interfaces apparaissent dans les packages et leur fichier 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, 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 à la fois statiques et définitifs.

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

  • Une interface peut étendre plusieurs interfaces.

Déclaration d'interfaces

le interfaceLe 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 leabstract mot-clé lors de la déclaration d'une interface.

  • Chaque méthode dans une interface est également implicitement abstraite, de sorte que 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();
}

Implémentation d'interfaces

Lorsqu'une classe implémente une interface, vous pouvez considérer la classe comme la signature d'un contrat, acceptant d'exécuter 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 comme abstraite.

Une classe utilise le implementsmot-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 -

Production

Mammal eats
Mammal travels

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

  • Les exceptions vérifié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 plus d'une interface à la fois.

  • Une classe ne peut étendre qu'une seule classe, mais implémenter plusieurs 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. leextends Le 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.

Extension de 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 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 Event, elle serait déclarée comme -

Exemple

public interface Hockey extends Sports, Event

Interfaces de balisage

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

Exemple

package java.util;
public interface EventListener
{}

Une interface sans méthode est appelée tagginginterface. La conception des interfaces de balisage a deux objectifs de base:

Creates a common parent- 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.

Adds a data type to a class- C'est de cette situation que vient le terme tagging. Une classe qui implémente une interface de balisage n'a pas besoin de définir de méthode (puisque l'interface n'en a pas), mais la classe devient un type d'interface par polymorphisme.