Adaptermuster

Teil des Abschnitts Objektorientierte Programmierung der Java-Journey von Coddy. Lektion 71 von 87.

Das Adapter-Muster ist ein strukturelles Entwurfsmuster, das es inkompatiblen Schnittstellen ermöglicht, zusammenzuarbeiten. Es fungiert als Brücke zwischen zwei Klassen und wandelt die Schnittstelle einer Klasse in eine Schnittstelle um, die der Client erwartet. Stell es dir wie einen Netzadapter vor, mit dem du ein europäisches Gerät an eine amerikanische Steckdose anschließen kannst.

Stell dir vor, du hast eine vorhandene MediaPlayer-Schnittstelle, die Audiodateien abspielt, aber du musst eine Bibliothek eines Drittanbieters integrieren, die zum Abspielen von Videos eine völlig andere Schnittstelle verwendet:

// Bestehende Schnittstelle, die dein Code verwendet
interface MediaPlayer {
    void play(String filename);
}

// Drittanbieter-Klasse mit inkompatibler Schnittstelle
class AdvancedVideoPlayer {
    public void playVideo(String filename) {
        System.out.println("Playing video: " + filename);
    }
}

Der Adapter umschließt die inkompatible Klasse und implementiert die erwartete Schnittstelle, wobei er Aufrufe zwischen ihnen übersetzt:

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

Jetzt kann dein Client-Code den Videoplayer über die vertraute MediaPlayer-Schnittstelle verwenden:

MediaPlayer player = new VideoPlayerAdapter();
player.play("movie.mp4");  // Ausgabe: Playing video: movie.mp4

Das Adapter-Muster ist von unschätzbarem Wert, wenn du Legacy-Code oder Bibliotheken von Drittanbietern integrierst, ohne deren Quellcode zu ändern. Der Client weiß nicht, dass er mit einer adaptierten Klasse arbeitet. Er verwendet einfach die Schnittstelle, die er kennt.

Aufgabe

Einfach

Erstellen wir ein Temperaturumrechnungssystem mithilfe des Adapter-Patterns! Du hast eine vorhandene Wetteranwendung, die mit Celsius-Temperaturen arbeitet, musst aber einen veralteten Temperatursensor integrieren, der Messwerte nur in Fahrenheit ausgibt. Anstatt eines der beiden Systeme zu ändern, erstellst du einen Adapter, der die Lücke überbrückt.

Du organisierst deinen Code über vier Dateien:

TemperatureProvider.java: Definiere die Schnittstelle, die deine Wetteranwendung erwartet. Sie sollte eine Methode getTemperatureCelsius() deklarieren, die einen double zurückgibt, der die Temperatur in Celsius darstellt.
FahrenheitSensor.java: Dies stellt den veralteten Sensor mit einer inkompatiblen Schnittstelle dar. Erstelle eine Klasse mit einem privaten double-Feld für die Temperatur in Fahrenheit, das über den Konstruktor gesetzt wird. Sie sollte eine Methode readFahrenheit() besitzen, die den gespeicherten Fahrenheit-Wert zurückgibt.
SensorAdapter.java: Erstelle den Adapter, der den Fahrenheit-Sensor mit deiner Wetteranwendung kompatibel macht. Dein Adapter sollte TemperatureProvider implementieren und einen FahrenheitSensor kapseln. Wenn getTemperatureCelsius() aufgerufen wird, sollte er den Sensor auslesen und den Wert mithilfe der Formel (fahrenheit - 32) * 5 / 9 in Celsius umrechnen.
Main.java: Führe alles zusammen! Du erhältst eine Eingabe: einen Temperaturmesswert in Fahrenheit (double).
Erstelle einen FahrenheitSensor mit dem Eingabewert. Erstelle anschließend einen SensorAdapter, der diesen Sensor kapselt. Speichere den Adapter in einer TemperatureProvider-Variablen, um zu zeigen, dass deine Wetteranwendung ihn über die erwartete Schnittstelle verwenden kann.

Gib das Ergebnis in diesem Format aus: Temperature: [celsius] C, wobei celsius mit einer Dezimalstelle formatiert wird.

Du erhältst eine Eingabe: die Fahrenheit-Temperatur (double).

Bei der Eingabe 98.6 wäre deine Ausgabe beispielsweise:

Temperature: 37.0 C

Beachte, dass deine Main-Klasse vollständig mit der Schnittstelle TemperatureProvider arbeitet. Sie weiß nicht, dass die tatsächliche Temperatur von einem Fahrenheit-Sensor stammt, der im Hintergrund adaptiert wird. Das ist die Eleganz des Adapter-Patterns!

Probier es selbst

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        double fahrenheit = scanner.nextDouble();
        
        // TODO: Erstelle einen FahrenheitSensor mit dem Eingabewert
        
        // TODO: Erstelle einen SensorAdapter, der den Sensor umhüllt
        
        // TODO: Speichere den Adapter in einer TemperatureProvider-Variable
        
        // TODO: Hole die Temperatur in Celsius und gib sie aus
        // Format: "Temperature: [celsius] C" mit einer Dezimalstelle
        // Hinweis: Verwende String.format("%.1f", value) zur Formatierung
    }
}