Patron Adaptateur

Fait partie de la section Programmation Orientée Objet du Journey Java de Coddy. Leçon 71 sur 87.

Le patron Adaptateur est un patron de conception structurel qui permet à des interfaces incompatibles de fonctionner ensemble. Il agit comme un pont entre deux classes, en convertissant l’interface d’une classe en une interface attendue par le client. Imaginez-le comme un adaptateur secteur qui vous permet de brancher un appareil européen sur une prise américaine.

Imagine que vous disposez d’une interface MediaPlayer existante qui lit des fichiers audio, mais que vous devez intégrer une bibliothèque tierce qui utilise une interface complètement différente pour lire des vidéos :

// Interface existante que votre code utilise
interface MediaPlayer {
    void play(String filename);
}

// Classe tierce avec une interface incompatible
class AdvancedVideoPlayer {
    public void playVideo(String filename) {
        System.out.println("Playing video: " + filename);
    }
}

L’adaptateur encapsule la classe incompatible et implémente l’interface attendue, en traduisant les appels entre elles :

class VideoPlayerAdapter implements MediaPlayer {
    private AdvancedVideoPlayer videoPlayer;
    
    public VideoPlayerAdapter() {
        this.videoPlayer = new AdvancedVideoPlayer();
    }
    
    public void play(String filename) {
        videoPlayer.playVideo(filename);
    }
}

Désormais, votre code client peut utiliser le lecteur vidéo via l’interface familière MediaPlayer :

MediaPlayer player = new VideoPlayerAdapter();
player.play("movie.mp4");  // Sortie : Lecture de la vidéo : movie.mp4

Le pattern Adapter est précieux lors de l’intégration de code existant ou de bibliothèques tierces sans modifier leur code source. Le client ignore qu’il travaille avec une classe adaptée. Il utilise simplement l’interface qu’il connaît.

Défi

Facile

Construisons un système de conversion de températures à l'aide du pattern Adapter ! Vous disposez d'une application météo existante qui fonctionne avec des températures en Celsius, mais vous devez intégrer un ancien capteur de température qui fournit uniquement des relevés en Fahrenheit. Au lieu de modifier l'un ou l'autre système, vous allez créer un adaptateur qui fera le lien entre eux.

Vous allez organiser votre code dans quatre fichiers :

TemperatureProvider.java : définissez l'interface attendue par votre application météo. Elle doit déclarer une méthode getTemperatureCelsius() qui renvoie un double représentant la température en Celsius.
FahrenheitSensor.java : cela représente l'ancien capteur avec une interface incompatible. Créez une classe avec un champ double privé pour la température en Fahrenheit, défini par le constructeur. Elle doit disposer d'une méthode readFahrenheit() qui renvoie la valeur Fahrenheit enregistrée.
SensorAdapter.java : créez l'adaptateur qui rend le capteur Fahrenheit compatible avec votre application météo. Votre adaptateur doit implémenter TemperatureProvider et encapsuler un FahrenheitSensor. Lorsque getTemperatureCelsius() est appelée, elle doit lire la valeur du capteur et la convertir en Celsius à l'aide de la formule : (fahrenheit - 32) * 5 / 9.
Main.java : rassemblez tous les éléments ! Vous recevrez une entrée : une température en Fahrenheit (double).
Créez un FahrenheitSensor avec la valeur d'entrée. Créez ensuite un SensorAdapter qui encapsule ce capteur. Stockez l'adaptateur dans une variable TemperatureProvider afin de démontrer que votre application météo peut l'utiliser via l'interface attendue.

Affichez le résultat dans ce format : Temperature: [celsius] C, où celsius est formaté avec une décimale.

Vous recevrez une entrée : la température en Fahrenheit (double).

Par exemple, avec l'entrée 98.6, votre sortie serait :

Temperature: 37.0 C

Remarquez que votre classe Main fonctionne entièrement avec l'interface TemperatureProvider. Elle ne sait pas que la température réelle provient d'un capteur Fahrenheit adapté en arrière-plan. Voilà toute l'élégance du pattern Adapter !

Essayez vous-même

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        double fahrenheit = scanner.nextDouble();
        
        // TODO: Créez un FahrenheitSensor avec la valeur d'entrée
        
        // TODO: Créez un SensorAdapter qui encapsule le capteur
        
        // TODO: Stockez l'adaptateur dans une variable TemperatureProvider
        
        // TODO: Obtenez la température en Celsius et affichez-la
        // Format : "Temperature: [celsius] C" avec une décimale
        // Astuce : Utilisez String.format("%.1f", value) pour le formatage
    }
}