Padrão Adapter

Parte da seção Programação Orientada a Objetos do Journey de Java da Coddy. Lição 71 de 87.

O padrão Adapter é um padrão de projeto estrutural que permite que interfaces incompatíveis trabalhem juntas. Ele atua como uma ponte entre duas classes, convertendo a interface de uma classe em uma interface que o cliente espera. Pense nele como um adaptador de energia que permite conectar um dispositivo europeu a uma tomada americana.

Imagine que você tenha uma interface MediaPlayer existente que reproduz arquivos de áudio, mas precise integrar uma biblioteca de terceiros que usa uma interface completamente diferente para reproduzir vídeos:

// Interface existente que seu código usa
interface MediaPlayer {
    void play(String filename);
}

// Classe de terceiros com interface incompatível
class AdvancedVideoPlayer {
    public void playVideo(String filename) {
        System.out.println("Playing video: " + filename);
    }
}

O adaptador envolve a classe incompatível e implementa a interface esperada, traduzindo as chamadas entre elas:

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

Agora seu código cliente pode usar o reprodutor de vídeo por meio da conhecida interface MediaPlayer:

MediaPlayer player = new VideoPlayerAdapter();
player.play("movie.mp4");  // Saída: Reproduzindo vídeo: movie.mp4

O Padrão Adapter é inestimável ao integrar código legado ou bibliotecas de terceiros sem modificar o código-fonte delas. O cliente permanece sem saber que está trabalhando com uma classe adaptada. Ele simplesmente usa a interface que conhece.

Desafio

Fácil

Vamos construir um sistema de conversão de temperatura usando o padrão Adapter! Você tem um aplicativo de previsão do tempo existente que trabalha com temperaturas em Celsius, mas precisa integrar um sensor de temperatura legado que fornece leituras apenas em Fahrenheit. Em vez de modificar qualquer um dos sistemas, você criará um adaptador que conecta os dois.

Você organizará seu código em quatro arquivos:

TemperatureProvider.java: Defina a interface que seu aplicativo de previsão do tempo espera. Ela deve declarar um método getTemperatureCelsius() que retorna um double representando a temperatura em Celsius.
FahrenheitSensor.java: Isso representa o sensor legado com uma interface incompatível. Crie uma classe com um campo double privado para a temperatura em Fahrenheit, definido por meio do construtor. Ela deve ter um método readFahrenheit() que retorna o valor armazenado em Fahrenheit.
SensorAdapter.java: Crie o adaptador que torna o sensor Fahrenheit compatível com seu aplicativo de previsão do tempo. Seu adaptador deve implementar TemperatureProvider e encapsular um FahrenheitSensor. Quando getTemperatureCelsius() for chamado, ele deve ler o valor do sensor e convertê-lo para Celsius usando a fórmula: (fahrenheit - 32) * 5 / 9.
Main.java: Reúna tudo! Você receberá uma entrada: uma leitura de temperatura em Fahrenheit (double).
Crie um FahrenheitSensor com o valor de entrada. Em seguida, crie um SensorAdapter que encapsule esse sensor. Armazene o adaptador em uma variável TemperatureProvider para demonstrar que seu aplicativo de previsão do tempo pode usá-lo por meio da interface esperada.

Imprima o resultado neste formato: Temperature: [celsius] C, em que celsius é formatado com uma casa decimal.

Você receberá uma entrada: a temperatura em Fahrenheit (double).

Por exemplo, com a entrada 98.6, sua saída seria:

Temperature: 37.0 C

Observe como sua classe Main trabalha inteiramente com a interface TemperatureProvider. Ela não sabe que a temperatura real vem de um sensor Fahrenheit adaptado nos bastidores. Essa é a elegância do padrão Adapter!

Experimente você mesmo

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        double fahrenheit = scanner.nextDouble();
        
        // TODO: Crie um FahrenheitSensor com o valor de entrada
        
        // TODO: Crie um SensorAdapter que envolve o sensor
        
        // TODO: Armazene o adapter em uma variável TemperatureProvider
        
        // TODO: Obtenha a temperatura em Celsius e imprima-a
        // Formato: "Temperature: [celsius] C" com uma casa decimal
        // Dica: Use String.format("%.1f", value) para formatação
    }
}