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 à l’aide du 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 qui implémentent la même interface peuvent être traitées uniformément :

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 fonctionne avec des références Drawable n’a pas besoin de connaître le type spécifique de la classe. Il se soucie uniquement du fait que l’objet puisse être dessiné.

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

Défi

Facile

Construisons un système de haut-parleurs qui montre comment les classes implémentent des interfaces. Vous allez créer une interface qui définit ce que tout haut-parleur peut faire, puis créer 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 disposer d’une méthode speak() qui renvoie une String. Il s’agit du contrat que toutes les classes qui l’implémentent doivent respecter.
Human.java : créez une classe qui implémente l’interface Speaker. Un Human possède un champ name (String). Ajoutez un constructeur pour initialiser le nom et implémentez la méthode speak() afin qu’elle renvoie : [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). Ajoutez un constructeur pour initialiser le modèle et implémentez la méthode speak() afin qu’elle renvoie : Robot [model] says: Beep boop!
Main.java : rassemblez tous les éléments en utilisant le polymorphisme fondé sur les interfaces. Vous recevrez deux entrées : un nom 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 Human et Robot peuvent tous deux être traités uniformément par l’intermédiaire de l’interface Speaker, même s’ils parlent de façons complètement différentes !

FORMAT DE SORTIE REQUIS :

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
    }
}