
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:
Cependant, une interface est différente d'une classe de plusieurs façons, y compris:
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:
Exemple:
/* File name : Animal.java */
interface Animal {
public void eat();
public void travel();
}
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:
Lorsque les interfaces de mise en œuvre existent en plusieurs règles:
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.
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
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.