Introduction aux Interfaces

Fait partie de la section Programmation Orientée Objet du Journey Java de Coddy — leçon 34 sur 87.

Vous avez vu comment les classes abstraites définissent des contrats que les sous-classes doivent suivre. Mais que se passe-t-il si vous voulez qu'une classe suive plusieurs contrats ? Java ne permet pas à une classe d'étendre plusieurs classes, mais il résout ce problème avec des interfaces.

Une interface est un contrat qui définit ce qu'une classe peut faire, sans spécifier comment elle le fait. Contrairement aux classes abstraites, les interfaces ne contiennent que des signatures de méthodes (par défaut) sans aucune implémentation :

public interface Drawable {
    void draw();
}

public interface Resizable {
    void resize(int width, int height);
}

Considérez une interface comme une promesse. Lorsqu'une classe implémente une interface, elle promet de fournir des implémentations pour toutes les méthodes déclarées dans cette interface. L'interface définit la capacité, et la classe fournit le comportement.

Les interfaces sont déclarées en utilisant le mot-clé interface au lieu de class. Toutes les méthodes d'une interface sont implicitement public et abstract, vous n'avez donc pas besoin d'écrire ces mots-clés :

public interface Playable {
    void play();    // implicitement public abstract
    void pause();
    void stop();
}

Les interfaces peuvent également déclarer des constantes, qui sont implicitement public static final :

public interface GameConstants {
    int MAX_PLAYERS = 4;  // implicitement public static final
}

Dans la prochaine leçon, vous apprendrez comment les classes implémentent des interfaces en utilisant le mot-clé implements.

Défi

Facile

Construisons un système de contrôle d'appareils en définissant des interfaces qui décrivent ce que différents appareils peuvent faire. Ce défi se concentre sur la création d'interfaces — les contrats qui définissent les capacités sans spécifier comment elles fonctionnent.

Vous organiserez votre code sur trois fichiers :

Switchable.java : Créez une interface qui définit ce que signifie pour un appareil d'être commutable. Tout appareil commutable doit pouvoir s'allumer et s'éteindre. Déclarez deux méthodes : turnOn() et turnOff(). Rappelez-vous, les méthodes d'interface sont implicitement publiques et abstraites, vous n'avez donc besoin que des signatures de méthode.
Adjustable.java : Créez une autre interface qui définit ce que signifie pour un appareil d'être réglable. Un appareil réglable doit pouvoir définir son niveau. Déclarez une méthode setLevel(int level). Incluez également une constante MAX_LEVEL avec une valeur de 100 — rappelez-vous que les constantes dans les interfaces sont implicitement public static final.
Main.java : Démontrez que vos interfaces sont correctement définies en affichant des informations à leur sujet. Vous recevrez une entrée : une valeur de niveau (int). Affichez les trois lignes suivantes :
- Switchable methods: turnOn, turnOff
- Adjustable methods: setLevel
- Max level constant: [MAX_LEVEL value] (accédez à la constante depuis l'interface Adjustable)
Ensuite, affichez : Setting level to: [input level]

Vous recevrez une entrée : une valeur de niveau (int).

Ce défi se concentre uniquement sur la définition d'interfaces — les plans qui décrivent les capacités. Dans la prochaine leçon, vous apprendrez comment les classes implémentent réellement ces interfaces pour fournir le comportement réel !

Aide-mémoire

Une interface est un contrat qui définit ce qu'une classe peut faire, sans spécifier comment elle le fait. Les interfaces ne contiennent que des signatures de méthodes sans implémentation.

Les interfaces sont déclarées en utilisant le mot-clé interface :

public interface Drawable {
    void draw();
}

Toutes les méthodes d'une interface sont implicitement public et abstract :

public interface Playable {
    void play();    // implicitement public abstract
    void pause();
    void stop();
}

Les interfaces peuvent déclarer des constantes, qui sont implicitement public static final :

public interface GameConstants {
    int MAX_PLAYERS = 4;  // implicitement public static final
}

Une classe peut implémenter plusieurs interfaces, contrairement à l'extension de plusieurs classes.

Essayez vous-même

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int level = scanner.nextInt();
        
        // TODO: Afficher des informations sur les interfaces
        // Afficher : "Switchable methods: turnOn, turnOff"
        // Afficher : "Adjustable methods: setLevel"
        // Afficher : "Max level constant: " suivi de Adjustable.MAX_LEVEL
        // Afficher : "Setting level to: " suivi du niveau saisi
        
    }
}