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 respecter. Mais que faire si vous voulez qu’une classe respecte plusieurs contrats ? Java n’autorise pas une classe à étendre plusieurs classes, mais résout ce problème avec les interfaces.

Une interface est un contrat qui définit ce qu’une classe peut faire, sans préciser comment elle le fait. Contrairement aux classes abstraites, les interfaces contiennent uniquement des signatures de méthodes (par défaut), sans 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 à l’aide du 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, tu apprendras comment les classes implémentent des interfaces à l’aide du 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 préciser comment elles fonctionnent.

Tu organiseras ton code sur trois fichiers :

Switchable.java : crée une interface qui définit ce que signifie être commutable pour un appareil. Tout appareil commutable doit pouvoir s’allumer et s’éteindre. Déclare deux méthodes : turnOn() et turnOff(). N’oublie pas que les méthodes d’une interface sont implicitement publiques et abstraites : tu dois donc seulement fournir les signatures des méthodes.
Adjustable.java : crée une autre interface qui définit ce que signifie être réglable pour un appareil. Un appareil réglable doit pouvoir définir son niveau. Déclare une méthode setLevel(int level). Inclus également une constante MAX_LEVEL ayant pour valeur 100 : rappelle-toi que les constantes dans les interfaces sont implicitement public static final.
Main.java : démontre que tes interfaces sont correctement définies en affichant des informations à leur sujet. Tu recevras une entrée : une valeur de niveau (int). Affiche les trois lignes suivantes :
- Switchable methods: turnOn, turnOff
- Adjustable methods: setLevel
- Max level constant: [MAX_LEVEL value] (accède à la constante depuis l’interface Adjustable)
Puis affiche : Setting level to: [input level]

Tu recevras 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, tu apprendras comment les classes implémentent réellement ces interfaces afin de fournir le comportement correspondant !

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 les informations sur les interfaces
        // Print: "Switchable methods: turnOn, turnOff"
        // Print: "Adjustable methods: setLevel"
        // Print: "Max level constant: " followed by Adjustable.MAX_LEVEL
        // Print: "Setting level to: " followed by the input level
        
    }
}