Implémentation d'Interfaces

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

Pour utiliser une interface, une classe doit l'implémenter en utilisant le mot-clé implements. La classe fournit ensuite des implémentations concrètes pour toutes les méthodes déclarées dans l'interface :

public interface Drawable {
    void draw();
}

public class Circle implements Drawable {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    @Override
    public void draw() {
        System.out.println("Drawing a circle with radius " + radius);
    }
}

Si une classe implémente une interface mais ne fournit pas d'implémentations pour toutes ses méthodes, le compilateur générera une erreur. L'annotation @Override est facultative mais recommandée car elle aide à détecter les erreurs.

Tout comme avec les classes abstraites, vous pouvez utiliser une interface comme type de référence. Cela permet le polymorphisme, où différentes classes implémentant la même interface peuvent être traitées de manière uniforme :

Drawable shape1 = new Circle(5.0);
Drawable shape2 = new Rectangle(4.0, 3.0);

shape1.draw();  // Dessin d'un cercle de rayon 5.0
shape2.draw();  // Dessin d'un rectangle 4.0 x 3.0

C'est puissant car le code qui travaille avec des références Drawable n'a pas besoin de connaître le type de classe spécifique. Il se soucie seulement du fait que l'objet puisse être dessiné.

Dans la prochaine leçon, vous verrez comment une seule classe peut implémenter plusieurs interfaces simultanément.

Défi

Facile

Construisons un système de haut-parleurs qui démontre comment les classes implémentent les interfaces. Vous allez créer une interface qui définit ce que tout haut-parleur peut faire, puis construire deux types de haut-parleurs différents qui implémentent chacun ce contrat à leur manière.

Vous organiserez votre code sur quatre fichiers :

Speaker.java : Définissez une interface appelée Speaker qui déclare ce que tout haut-parleur doit être capable de faire. Chaque haut-parleur doit avoir une méthode speak() qui retourne un String—c'est le contrat que toutes les classes d'implémentation doivent remplir.
Human.java : Créez une classe qui implémente l'interface Speaker. Un Human possède un champ name (String). Incluez un constructeur pour initialiser le nom, et implémentez la méthode speak() pour retourner : [name] says: Hello everyone!
Robot.java : Créez une autre classe qui implémente l'interface Speaker. Un Robot possède un champ model (String). Incluez un constructeur pour initialiser le modèle, et implémentez la méthode speak() pour retourner : Robot [model] says: Beep boop!
Main.java : Rassemblez le tout en utilisant le polymorphisme basé sur les interfaces. Vous recevrez deux entrées : un nom d'humain et un modèle de robot. Créez un Human et un Robot, puis stockez-les dans un tableau de références Speaker. Parcourez le tableau et affichez le résultat de l'appel à speak() sur chaque haut-parleur.

Vous recevrez deux entrées : le nom de l'humain (String) et le modèle du robot (String).

Votre sortie doit afficher deux lignes—une pour chaque haut-parleur. Remarquez comment le Human et le Robot peuvent être traités de manière uniforme via l'interface Speaker, même s'ils s'expriment de manières complètement différentes !

Aide-mémoire

Une classe utilise le mot-clé implements pour implémenter une interface et doit fournir des implémentations concrètes pour toutes les méthodes déclarées dans l'interface :

public interface Drawable {
    void draw();
}

public class Circle implements Drawable {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    @Override
    public void draw() {
        System.out.println("Drawing a circle with radius " + radius);
    }
}

L'annotation @Override est facultative mais recommandée car elle aide à détecter les erreurs.

Les interfaces peuvent être utilisées comme types de référence, permettant le polymorphisme où différentes classes implémentant la même interface peuvent être traitées de manière uniforme :

Drawable shape1 = new Circle(5.0);
Drawable shape2 = new Rectangle(4.0, 3.0);

shape1.draw();  // Dessiner un cercle de rayon 5.0
shape2.draw();  // Dessiner un rectangle 4.0 x 3.0

Essayez vous-même

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Lire les entrées
        String humanName = scanner.nextLine();
        String robotModel = scanner.nextLine();
        
        // TODO: Créer un objet Human avec le nom donné
        
        // TODO: Créer un objet Robot avec le modèle donné
        
        // TODO: Créer un tableau de références Speaker contenant les deux objets
        
        // TODO: Parcourir le tableau et afficher le résultat de speak() pour chaque speaker
    }
}