Les 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.
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 static et
final.
 Une interface n'est pas étendue par une classe ; elle est implémentée par une
classe.
 Une interface peut étendre plusieurs interfaces.

Déclaration des interfaces

Le mot clé interface 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
mot clé abstract lors de la déclaration d'une interface.
 Chaque méthode d'une interface est aussi 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 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 le mot clé implements pour implémenter une interface. Le mot clé
implements apparaît dans la déclaration de classe à la suite de 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 de la redéfinition des méthodes définies dans les interfaces, il y a plusieurs règles à
suivre -
 La signature de la méthode d'interface et le même type de retour doivent être
conservés lors de la redéfinition 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 l'implémentation 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.

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.
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é extends 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

Que ce qui se passe lorsqu'une classe implémente plusieurs interfaces qui

définissent les mêmes méthodes par défaut .
Pour mieux comprendre ce scénario, définissons une nouvelle interface d' alarme et
refactorisons la classe Car :
public interface Alarm {

default String turnAlarmOn() {

return "Turning the alarm on.";
}

default String turnAlarmOff() {

return "Turning the alarm off.";
}
}
Avec cette nouvelle interface définissant son propre ensemble de méthodes par
défaut , la classe Car implémenterait à la fois Vehicle et Alarm :

public class Car implements Vehicle, Alarm {

// ...
}
Dans ce cas, le code ne sera tout simplement pas compilé, car il existe un conflit
causé par l'héritage d'interfaces multiples. La classe Car hériterait des deux
ensembles de méthodes par défaut . Alors lesquels doit-on appeler ?
Pour résoudre cette ambiguïté, nous devons explicitement fournir une
implémentation des méthodes :
@Override
public String turnAlarmOn() {
// custom implementation
}

@Override
public String turnAlarmOff() {
// custom implementation
}
Nous pouvons également faire en sorte que notre classe utilise les méthodes par
défaut de l'une des interfaces.
Voyons un exemple qui utilise les méthodes par défaut de l' interface Vehicle :
@Override
public String turnAlarmOn() {
return Vehicle.super.turnAlarmOn();
}

@Override
public String turnAlarmOff() {
return Vehicle.super.turnAlarmOff();
}
De même, nous pouvons faire en sorte que la classe utilise les méthodes par
défaut définies dans l' interface Alarm :

@Override
public String turnAlarmOn() {
return Alarm.super.turnAlarmOn();
}

@Override
public String turnAlarmOff() {
return Alarm.super.turnAlarmOff();
}

Il est même possible de faire en sorte que la classe Car utilise les deux
ensembles de méthodes par défaut :
@Override
public String turnAlarmOn() {
return Vehicle.super.turnAlarmOn() + " " + Alarm.super.turnAlarmOn();
}

@Override
public String turnAlarmOff() {
return Vehicle.super.turnAlarmOff() + " " + Alarm.super.turnAlarmOff();
}