4.12. Syntaxe Java de base : interfaces

Les interfaces en Java sont une fonctionnalité fondamentale qui vous permet de définir un contrat que les classes peuvent implémenter. Ils constituent un moyen de réaliser l'abstraction en Java et sont cruciaux pour la conception de logiciels, en particulier lorsqu'il s'agit de grands systèmes et frameworks. Lors de l'apprentissage de Java, la compréhension des interfaces est essentielle pour passer à la programmation de niveau intermédiaire et avancé.

Concept d'interface

Une interface est une collection de méthodes abstraites et de constantes statiques. Les méthodes abstraites sont celles qui sont déclarées sans implémentation. Lorsqu'une classe implémente une interface, elle doit fournir des implémentations concrètes pour toutes les méthodes abstraites déclarées dans l'interface. Cela garantit que la classe suit le "contrat" ​​établi par l'interface.

Déclaration d'interface

Pour déclarer une interface en Java, vous utilisez le mot clé interface. Voici un exemple simple :

interface publique Véhicule {
    int MAX_SPEED = 120 ; // constante statique
    vide start(); // méthode abstraite
    annuler l'arrêt (); // méthode abstraite
    void accélérer (vitesse int); // méthode abstraite

Notez que les méthodes au sein d'une interface sont implicitement publiques et abstraites, vous n'avez donc pas besoin de spécifier ces modificateurs. Les constantes sont publiques, statiques et finales par définition.

Implémentation des interfaces

Lorsqu'une classe implémente une interface, elle utilise le mot-clé implements. Voici un exemple de classe qui implémente l'interface Vehicle :

classe publique Car met en œuvre Véhicule {
    public void start() {
        // implémentation de la méthode start
    }
    
    public void arrêt() {
        // implémentation de la méthode stop
    }
    
    public void accélérer (vitesse int) {
        // implémentation de la méthode accélérée
    }

Si une classe ne fournit pas d'implémentations pour toutes les méthodes abstraites de l'interface, elle doit être déclarée abstraite.

Interfaces et héritage

L'un des grands avantages des interfaces est qu'elles peuvent être utilisées pour simuler un héritage multiple, ce qui n'est pas possible avec les classes Java. Une classe peut implémenter plusieurs interfaces, en les séparant par des virgules :

Classe publique ElectricCar implémente Vehicle, EcoFriendly {
    // mise en place des méthodes Véhicule et EcoFriendly

Cela permet à la classe ElectricCar d'avoir des comportements définis par plusieurs interfaces.

Méthodes par défaut

À partir de Java 8, les interfaces peuvent avoir des méthodes default, qui ont une implémentation par défaut. Cela permet d'ajouter de nouvelles méthodes aux interfaces sans casser les classes qui les implémentent. Par exemple :

interface publique Véhicule {
    // méthodes abstraites
    
    par défaut void turnAlarmOn() {
        // implémentation par défaut de la méthode turnAlarmOn
    }
    
    par défaut void turnAlarmOff() {
        // implémentation par défaut de la méthode turnAlarmOff
    }

Les classes qui implémentent l'interface Vehicle peuvent choisir d'utiliser ces implémentations par défaut ou de fournir les leurs.

Méthodes statiques

Les interfaces peuvent également avoir des méthodes statiques. Ce sont des méthodes qui peuvent être appelées au nom de l'interface, sans avoir besoin d'une instance :

interface publique Véhicule {
    // méthodes abstraites et par défaut
    
    Chaîne statique getVehicleType() {
        renvoyer « Type de véhicule inconnu » ;
    }

Cette méthode peut être appelée comme ceci : String type = Vehicle.getVehicleType();

Interfaces fonctionnelles

Une interface fonctionnelle est une interface qui contient exactement une méthode abstraite. Ils servent de base aux expressions lambda et aux références de méthodes. Java 8 a introduit l'annotation @FunctionalInterface pour indiquer qu'une interface est destinée à être une interface fonctionnelle :