Notion d’interface, syntaxe de déclaration

1. Qu’est-ce qu’une interface ?

Si une classe abstraite est le plan d’une maison, une interface est plutôt un contrat sur l’exécution de travaux précis. Par exemple, si vous appelez un plombier, vous vous attendez à ce qu’il puisse « réparer le robinet » et « éliminer une fuite ». Comment il s’y prend — cela ne vous importe pas ; l’essentiel est le résultat. En Java, une interface est justement un tel contrat : elle indique quelles méthodes doivent être implémentées, mais pas comment.

En bref :

Une interface est un type spécial en Java qui définit un ensemble de méthodes que les classes ayant « souscrit » à cette interface doivent implémenter.

• L’interface décrit seulement « quoi faire », mais pas « comment faire ».
• Jusqu’à Java 8, les interfaces ne contenaient pas d’implémentations de méthodes.
• Une interface est un contrat pur : si une classe implémente une interface, elle doit implémenter toutes ses méthodes.

Pourquoi est-ce pratique ?

• On peut « accrocher » plusieurs interfaces à une classe — c’est-à-dire lui donner plusieurs « rôles ».
• Permet de construire des architectures flexibles et extensibles, où les classes peuvent implémenter différentes capacités.
• Les interfaces sont largement utilisées dans la bibliothèque standard Java (par exemple Comparable, Serializable, Runnable, etc.).

2. Syntaxe de déclaration d’une interface

Déclarer une interface en Java est très simple. On utilise pour cela le mot-clé interface. Jusqu’à Java 8, les méthodes d’une interface étaient par défaut public abstract, même si cela n’était pas écrit explicitement. Cela signifie : la méthode doit être implémentée dans la classe qui implémente l’interface.

Exemple d’interface

public interface Movable {
    void move(int x, int y);
}

• Ici, nous avons déclaré l’interface Movable (qu’on peut traduire par « mobile » ou « capable de se déplacer »).
• À l’intérieur, la méthode move(int x, int y) est déclarée. Pas de corps — uniquement la signature. C’est le « contrat » : « si vous implémentez Movable, implémentez move ».

Particularités de la syntaxe

• Les méthodes d’une interface n’ont pas de corps (jusqu’à Java 8).
• Toutes les méthodes d’une interface sont par défaut public abstract (il n’est pas nécessaire de l’écrire).
• Une interface peut ne contenir que des constantes (public static final), mais pas de champs ordinaires.

Exemple avec constante

public interface Constants {
    int MAX_SPEED = 100; // public static final par défaut
}

3. Différence entre une interface et une classe

Une interface n’est pas une classe ! Voyons en quoi elles diffèrent.

Une classe implémente une interface avec implements

public class Robot implements Movable {
    @Override
    public void move(int x, int y) {
        System.out.println("Le robot se déplace vers le point (" + x + ", " + y + ")");
    }
}

• La classe Robot implémente l’interface Movable.
• Le mot-clé implements — « implémente ».
• Il faut implémenter toutes les méthodes de l’interface (sinon il y aura une erreur de compilation).
• N’oubliez pas l’annotation @Override — elle n’est pas obligatoire, mais elle aide le compilateur et vous évite des erreurs.

4. Exemple d’utilisation d’une interface

Écrivons un petit exemple pour voir comment cela fonctionne en pratique. Imaginons que nous ayons l’interface Movable et que nous voulions que différentes classes puissent « se déplacer » : un robot, une voiture, un animal…

Étape 1. Déclarer l’interface

public interface Movable {
    void move(int x, int y);
}

Étape 2. Implémenter l’interface dans une classe

public class Robot implements Movable {
    @Override
    public void move(int x, int y) {
        System.out.println("Le robot se déplace vers le point (" + x + ", " + y + ")");
    }
}

Étape 3. Utiliser l’interface

public class Main {
    public static void main(String[] args) {
        Movable m = new Robot(); // Variable de type interface !
        m.move(10, 20); // Affichera : Le robot se déplace vers le point (10, 20)
    }
}

À noter

• Nous pouvons déclarer une variable de type interface (Movable m) et lui affecter un objet d’une classe qui implémente cette interface (new Robot()).
• Cela permet d’écrire du code générique qui fonctionne avec n’importe quel objet « mobile », sans savoir de quelle classe il s’agit réellement.

Erreur de compilation si la méthode n’est pas implémentée

Error: Class 'Robot' must either be declared abstract or implement abstract method 'move(int, int)' in 'Movable'

C’est là toute la force des interfaces — elles garantissent que toutes les classes qui les implémentent possèdent les méthodes requises.

5. Interfaces dans la bibliothèque standard Java

Les interfaces ne sont pas qu’un sujet « scolaire ». Elles sont utilisées activement dans toute la bibliothèque standard Java. Voici quelques exemples :

• Comparable<T> — interface pour comparer des objets (par exemple lors d’un tri).
• Runnable — interface pour exécuter un thread.
• Serializable — interface marqueur indiquant qu’un objet peut être sérialisé.
• List, Set, Map — interfaces de collections.

Exemple : Comparable

public class Person implements Comparable<Person> {
    String name;
    int age;

    // Constructeur et autres méthodes...

    @Override
    public int compareTo(Person other) {
        return this.age - other.age;
    }
}

Les objets Person peuvent désormais être triés, car ils implémentent l’interface Comparable.

6. Schéma visuel : fonctionnement d’une interface

+-------------------+         +-------------------+
|   interface       |         |    class          |
|   Movable         |<--------|    Robot          |
|-------------------|         |-------------------|
| +move(int, int)   |         | +move(int, int)   |
+-------------------+         +-------------------+

• La flèche montre que la classe Robot implémente l’interface Movable.
• L’interface ne définit que « ce qui doit exister », la classe — « comment cela fonctionne ».

Analogie de la vie courante

Une interface en Java, c’est comme un permis de conduire. Si vous avez un permis (vous implémentez l’interface « Conducteur »), alors vous savez conduire une voiture. La manière exacte dont vous conduisez — c’est un détail : certains conduisent prudemment, d’autres vite, mais l’essentiel est que vous vous êtes engagés à savoir le faire.

7. Exemple pratique : poursuivons notre application

public interface Movable {
    void move(int x, int y);
}

public class Animal implements Movable {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    @Override
    public void move(int x, int y) {
        System.out.println(name + " se déplace vers le point (" + x + ", " + y + ")");
    }
}

public class Robot implements Movable {
    private String model;

    public Robot(String model) {
        this.model = model;
    }

    @Override
    public void move(int x, int y) {
        System.out.println("Le robot " + model + " se dirige vers les coordonnées (" + x + ", " + y + ")");
    }
}

public class Main {
    public static void main(String[] args) {
        Movable[] movables = {
            new Animal("Buddy"),
            new Robot("R2D2")
        };

        for (Movable m : movables) {
            m.move(5, 10);
        }
    }
}

Résultat :

Buddy se déplace vers le point (5, 10)
Le robot R2D2 se dirige vers les coordonnées (5, 10)

Nous avons créé un tableau d’objets de type Movable. Il peut contenir n’importe quels objets implémentant cette interface ! Le code de la boucle ne sait pas de quoi il s’agit — animal ou robot —, mais il sait que chacun d’eux sait faire move.

8. Erreurs typiques lors de l’utilisation des interfaces

Erreur n° 1 : tentative de créer directement une instance d’interface. Une interface est un contrat, pas un objet concret. On ne peut pas écrire new Movable() — cela provoquera une erreur de compilation. Il faut créer des objets des classes qui implémentent l’interface.

Erreur n° 2 : toutes les méthodes de l’interface ne sont pas implémentées. Si une classe implémente une interface mais n’implémente pas toutes ses méthodes, le compilateur signalera une erreur : « Class must either be declared abstract or implement abstract method ... ». Si vous ne souhaitez pas implémenter toutes les méthodes, déclarez la classe abstract.

Erreur n° 3 : oubli des modificateurs d’accès. Les méthodes d’une interface sont toujours public (même si ce n’est pas écrit). Dans la classe qui implémente, il est interdit de réduire le niveau d’accès, donc la méthode doit également être public.

Erreur n° 4 : tentative d’ajouter des champs ordinaires dans une interface. Dans une interface, on peut déclarer uniquement des constantes (public static final). Il est impossible d’ajouter des champs ordinaires (non statiques).