Comprendre les interfaces Java : Définitions, Usages et Bonnes pratiques

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

Une interface peut aussi contenir : constantes, méthodes par défaut (default), méthodes statiques, types imbriqués. Seules les méthodes default et static ont un corps.

Interface vs Classe

Similitudes :

• Nombre illimité de méthodes
• Fichier .java (nom = interface)
• Bytecode dans fichier .class
• Organisées en packages

Différences :

• Ne peut pas être instanciée
• Pas de constructeurs
• Toutes les méthodes sont implicitement abstract (sauf default/static)
• Pas de champs d'instance (seuls static final = constantes)
• Une classe n'étend pas une interface, elle l'implémente
• Une interface peut étendre plusieurs interfaces

Déclaration d'interface

/* NomInterface.java */
import java.lang.*;

public interface NomInterface {
    // constantes static final
    // déclarations de méthodes abstraites
}

Propriétés :

• Implicitement abstract (mot-clé inutile)
• Méthodes implicitement public abstract

Exemple simple

interface Animal {
    public void manger();
    public void voyager();
}

Implémentation d'interface

Une classe implémentant une interface "signe un contrat" : elle doit fournir toutes les méthodes (sauf si elle est abstraite).

Mot-clé : implements (après extends s'il y a lieu).

Exemple

public class MammifereImpl implements Animal {
    public void manger() {
        System.out.println("Mammifère mange");
    }
    
    public void voyager() {
        System.out.println("Mammifère voyage");
    }
    
    public int nombrePattes() { return 0; }
    
    public static void main(String args[]) {
        MammifereImpl m = new MammifereImpl();
        m.manger();
        m.voyager();
    }
}

Résultat :

Mammifère mange
Mammifère voyage

Règles de redéfinition

• Exceptions vérifiées : seulement celles déclarées dans l'interface ou leurs sous-types
• Signature et type de retour (ou sous-type) identiques
• La classe d'implémentation peut être abstraite (méthodes non requises)

Règles d'implémentation

• Une classe peut implémenter plusieurs interfaces
• Une classe ne peut étendre qu'une seule classe, mais implémenter plusieurs interfaces
• Une interface peut étendre une autre interface (comme une classe étend une classe)

Extension d'interfaces

Mot-clé extends. L'interface fille hérite des méthodes de la parente.

Exemple : Sports, Football, Hockey

// Sports.java
public interface Sports {
    public void setEquipeDomicile(String nom);
    public void setEquipeVisiteur(String nom);
}

// Football.java
public interface Football extends Sports {
    public void butDomicile(int points);
    public void butVisiteur(int points);
    public void finQuartTemps(int quart);
}

// Hockey.java
public interface Hockey extends Sports {
    public void butDomicile();
    public void butVisiteur();
    public void finPeriode(int periode);
    public void prolongation(int ot);
}

Hockey a 4 méthodes propres + 2 héritées = 6 à implémenter. Football : 3 + 2 = 5.

Extension de multiples interfaces

Une classe ne peut étendre qu'une classe, mais une interface peut étendre plusieurs interfaces :

public interface Hockey extends Sports, Evenement { }

Interfaces de marquage (Tagging Interfaces)

Interface sans méthodes. Exemple : java.util.EventListener :

package java.util;
public interface EventListener {}

Deux usages :

1. Parent commun : EventListener est étendue par des dizaines d'interfaces (MouseListener, etc.). La JVM sait qu'une interface étendant EventListener sert à la délégation d'événements.
2. Ajout de type à une classe : une classe implémentant une interface de marquage n'a pas de méthodes à définir, mais devient de ce type par polymorphisme (ex: Serializable, Cloneable).