Implémentation d'Interfaces Multiples

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

Contrairement à l'héritage de classe où vous ne pouvez étendre qu'une seule classe, Java permet à une classe d'implémenter plusieurs interfaces. C'est ainsi que Java réalise une forme d'héritage multiple en toute sécurité.

Pour implémenter plusieurs interfaces, listez-les après le mot-clé implements, séparés par des virgules :

public interface Drawable {
    void draw();
}

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

public class Rectangle implements Drawable, Resizable {
    private int width, height;
    
    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }
    
    @Override
    public void draw() {
        System.out.println("Drawing rectangle " + width + "x" + height);
    }
    
    @Override
    public void resize(int width, int height) {
        this.width = width;
        this.height = height;
    }
}

La classe doit implémenter toutes les méthodes de chaque interface qu'elle déclare. Vous pouvez également combiner l'héritage avec plusieurs interfaces :

public class Square extends Shape implements Drawable, Resizable {
    // Doit implémenter les méthodes des deux interfaces
    // Peut également utiliser les membres hérités de Shape
}

Cette flexibilité vous permet de concevoir des classes qui remplissent plusieurs rôles. Un SmartPhone pourrait implémenter les interfaces Callable, Messageable et Browsable, chacune définissant différentes capacités prises en charge par le téléphone.

Défi

Facile

Construisons un système d'appareils intelligents où les appareils peuvent avoir plusieurs capacités. Vous allez créer une SmartTV qui peut à la fois être allumée/éteinte et dont le volume peut être contrôlé, démontrant ainsi comment une seule classe peut implémenter plusieurs interfaces pour remplir différents rôles.

Vous organiserez votre code sur quatre fichiers :

Powerable.java : Définissez une interface pour les appareils qui peuvent être alimentés. Elle doit déclarer deux méthodes : powerOn() et powerOff(), toutes deux retournant void.
VolumeControl.java : Définissez une interface pour les appareils avec contrôle du volume. Elle doit déclarer une méthode setVolume(int level) qui retourne void, et une méthode getVolume() qui retourne un int.
SmartTV.java : Créez une classe qui implémente les deux interfaces Powerable et VolumeControl. Votre SmartTV doit avoir un champ brand (String), un champ isOn (boolean, initialement false), et un champ volume (int, initialement 0). Incluez un constructeur qui prend le nom de la marque. Implémentez toutes les méthodes requises :
- powerOn() doit définir isOn à true et afficher : [brand] TV is now ON
- powerOff() doit définir isOn à false et afficher : [brand] TV is now OFF
- setVolume(int level) doit mettre à jour le volume et afficher : [brand] TV volume set to [level]
- getVolume() doit retourner le volume actuel
Main.java : Rassemblez tout pour démontrer l'implémentation d'interfaces multiples. Vous recevrez deux entrées : un nom de marque (String) et un niveau de volume (int). Créez une SmartTV avec la marque donnée, puis :
- Appelez powerOn()
- Appelez setVolume() avec le niveau donné
- Affichez : Current volume: [volume] en utilisant getVolume()
- Appelez powerOff()

Vous recevrez deux entrées : la marque de la TV (String) et le niveau de volume (int).

Votre sortie devrait afficher quatre lignes démontrant comment votre SmartTV remplit les contrats des deux interfaces — elle peut être alimentée comme n'importe quel appareil Powerable et son volume peut être contrôlé comme n'importe quel appareil VolumeControl !

Aide-mémoire

Une classe peut implémenter plusieurs interfaces en les listant après le mot-clé implements, séparées par des virgules :

public class Rectangle implements Drawable, Resizable {
    // Doit implémenter toutes les méthodes des deux interfaces
}

La classe doit implémenter toutes les méthodes de chaque interface qu'elle déclare.

Vous pouvez également combiner l'héritage de classe avec l'implémentation d'interfaces multiples :

public class Square extends Shape implements Drawable, Resizable {
    // Implémente les méthodes des deux interfaces
    // Peut utiliser les membres hérités de Shape
}

Cela permet à une classe de remplir plusieurs rôles et d'avoir différentes capacités.

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 brand = scanner.nextLine();
        int volumeLevel = scanner.nextInt();
        
        // TODO: Créer une SmartTV avec la marque donnée
        
        // TODO: Appeler powerOn()
        
        // TODO: Appeler setVolume() avec le niveau donné
        
        // TODO: Afficher : Current volume: [volume] en utilisant getVolume()
        
        // TODO: Appeler powerOff()
        
    }
}