Pattern Adapter

Fa parte della sezione Programmazione orientata agli oggetti del percorso Java di Coddy. Lezione 71 di 87.

L'Adapter Pattern è un pattern strutturale che consente a interfacce incompatibili di funzionare insieme. Agisce da ponte tra due classi, convertendo l'interfaccia di una classe in un'interfaccia che il client si aspetta. Pensalo come a un adattatore di corrente che ti permette di collegare un dispositivo europeo a una presa americana.

Immagina di avere un'interfaccia MediaPlayer esistente che riproduce file audio, ma di dover integrare una libreria di terze parti che usa un'interfaccia completamente diversa per riprodurre video:

// Interfaccia esistente utilizzata dal tuo codice
interface MediaPlayer {
    void play(String filename);
}

// Classe di terze parti con un'interfaccia incompatibile
class AdvancedVideoPlayer {
    public void playVideo(String filename) {
        System.out.println("Playing video: " + filename);
    }
}

L'adattatore avvolge la classe incompatibile e implementa l'interfaccia prevista, traducendo le chiamate tra le due:

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

Ora il tuo codice client può usare il lettore video tramite la familiare interfaccia MediaPlayer:

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

Il Pattern Adapter è prezioso quando si integrano codice legacy o librerie di terze parti senza modificarne il codice sorgente. Il client non si accorge di lavorare con una classe adattata. Usa semplicemente l’interfaccia che conosce.

Sfida

Facile

Creiamo un sistema di conversione della temperatura usando il Pattern Adapter! Hai un'applicazione meteo esistente che lavora con temperature in Celsius, ma devi integrare un sensore di temperatura legacy che fornisce letture solo in Fahrenheit. Invece di modificare uno dei due sistemi, creerai un adapter che colma il divario.

Organizzerai il codice in quattro file:

TemperatureProvider.java: Definisci l'interfaccia che si aspetta la tua applicazione meteo. Dovrebbe dichiarare un metodo getTemperatureCelsius() che restituisce un double che rappresenta la temperatura in Celsius.
FahrenheitSensor.java: Rappresenta il sensore legacy con un'interfaccia incompatibile. Crea una classe con un campo double privato per la temperatura in Fahrenheit, impostato tramite il costruttore. Dovrebbe avere un metodo readFahrenheit() che restituisce il valore Fahrenheit memorizzato.
SensorAdapter.java: Crea l'adapter che rende il sensore Fahrenheit compatibile con la tua applicazione meteo. L'adapter dovrebbe implementare TemperatureProvider e racchiudere un FahrenheitSensor. Quando viene chiamato getTemperatureCelsius(), dovrebbe leggere il valore dal sensore e convertirlo in Celsius usando la formula: (fahrenheit - 32) * 5 / 9.
Main.java: Metti insieme tutti gli elementi! Riceverai un input: una lettura della temperatura in Fahrenheit (double).
Crea un FahrenheitSensor con il valore di input. Poi crea un SensorAdapter che racchiuda questo sensore. Memorizza l'adapter in una variabile di tipo TemperatureProvider per dimostrare che la tua applicazione meteo può usarlo tramite l'interfaccia prevista.

Stampa il risultato in questo formato: Temperature: [celsius] C dove celsius è formattato con una cifra decimale.

Riceverai un input: la temperatura in Fahrenheit (double).

Per esempio, con l'input 98.6, l'output sarà:

Temperature: 37.0 C

Nota come la tua classe Main lavori interamente con l'interfaccia TemperatureProvider. Non sa che la temperatura effettiva proviene da un sensore Fahrenheit adattato dietro le quinte. Questa è l'eleganza del Pattern Adapter!

Provalo tu

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        double fahrenheit = scanner.nextDouble();
        
        // TODO: Crea un FahrenheitSensor con il valore di input
        
        // TODO: Crea un SensorAdapter che incapsuli il sensore
        
        // TODO: Memorizza l'adattatore in una variabile TemperatureProvider
        
        // TODO: Ottieni la temperatura in Celsius e stampala
        // Formato: "Temperature: [celsius] C" con una cifra decimale
        // Suggerimento: usa String.format("%.1f", value) per la formattazione
    }
}