Padrão Observer

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

O padrão Observer é um padrão comportamental de projeto que estabelece uma relação de um para muitos entre objetos. Quando um objeto (o assunto) muda de estado, todas as suas dependências (os observadores) são automaticamente notificadas e atualizadas. Pense nisso como uma assinatura de newsletter: os assinantes recebem atualizações sempre que um novo conteúdo é publicado.

O padrão envolve dois componentes principais: um sujeito que mantém uma lista de observadores e os notifica sobre mudanças, e observadores que definem um método de atualização para responder às notificações:

import java.util.ArrayList;
import java.util.List;

interface Observer {
    void update(String message);
}

class NewsPublisher {
    private List<Observer> subscribers = new ArrayList<>();
    
    public void subscribe(Observer observer) {
        subscribers.add(observer);
    }
    
    public void unsubscribe(Observer observer) {
        subscribers.remove(observer);
    }
    
    public void publish(String news) {
        for (Observer subscriber : subscribers) {
            subscriber.update(news);
        }
    }
}

class EmailSubscriber implements Observer {
    private String email;
    
    public EmailSubscriber(String email) {
        this.email = email;
    }
    
    public void update(String message) {
        System.out.println("Email to " + email + ": " + message);
    }
}

Quando o editor publica notícias, todos os assinantes são notificados automaticamente:

NewsPublisher publisher = new NewsPublisher();
publisher.subscribe(new EmailSubscriber("alice@mail.com"));
publisher.subscribe(new EmailSubscriber("bob@mail.com"));

publisher.publish("Breaking news!");
// Saída:
// E-mail para alice@mail.com: Breaking news!
// E-mail para bob@mail.com: Breaking news!

O Padrão Observer promove baixo acoplamento: o sujeito não precisa conhecer as classes concretas de seus observadores, apenas que eles implementam a interface Observer. Isso facilita adicionar novos tipos de observadores sem modificar o sujeito.

Desafio

Fácil

Vamos criar um sistema de alerta de preços de ações usando o Padrão Observer! Você criará um sistema em que um ticker de ações notifica vários investidores sempre que o preço da ação muda, permitindo que cada investidor reaja às atualizações de preço à sua própria maneira.

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

Observer.java: defina a interface Observer que todos os investidores implementarão. Ela deve declarar um único método update(String stockName, double price) que os observadores usarão para receber notificações sobre mudanças de preço.
StockTicker.java: crie a classe subject que mantém uma lista de observadores e os notifica sobre mudanças de preço. Seu StockTicker deve ter:
Um campo privado do tipo String para o nome da ação (definido pelo construtor).

Um campo privado do tipo double para o preço atual (inicialmente 0).

Uma lista privada para armazenar os observadores inscritos.

Um método subscribe(Observer observer) que adiciona um observador à lista.

Um método unsubscribe(Observer observer) que remove um observador da lista.

Um método setPrice(double price) que atualiza o preço e, em seguida, notifica todos os observadores chamando o método update deles com o nome da ação e o novo preço.
Investors.java: crie dois tipos diferentes de investidores que implementam a interface Observer:
DayTrader - tem um campo privado para o nome, definido pelo construtor. Quando atualizado, imprime [name] received alert: [stockName] is now $[price] - Making quick trade!

LongTermInvestor - tem um campo privado para o nome, definido pelo construtor. Quando atualizado, imprime [name] received alert: [stockName] is now $[price] - Holding steady.

Formate o preço com duas casas decimais.
Main.java: reúna seu sistema de observadores! Você receberá três entradas: o nome da ação (String), a primeira atualização de preço (double) e a segunda atualização de preço (double).
Crie um StockTicker com o nome da ação fornecido. Crie um DayTrader chamado "Alice" e um LongTermInvestor chamado "Bob", e inscreva ambos no ticker.

Defina o preço como o primeiro valor de entrada (todos os observadores serão notificados). Em seguida, cancele a inscrição de Alice. Por fim, defina o preço como o segundo valor de entrada (somente Bob deverá ser notificado desta vez).

Você receberá três entradas nesta ordem: nome da ação (String), primeiro preço (double), segundo preço (double).

Este desafio demonstra o poder do Padrão Observer: o StockTicker não sabe nada sobre os tipos específicos de investidores. Ele apenas sabe que eles implementam Observer. Quando você cancela a inscrição de Alice, ela para de receber atualizações, enquanto Bob continua sendo notificado. Esse baixo acoplamento facilita a adição de novos tipos de investidores sem alterar o ticker!

Experimente você mesmo

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Ler entradas
        String stockName = scanner.nextLine();
        double firstPrice = scanner.nextDouble();
        double secondPrice = scanner.nextDouble();
        
        // TODO: Crie um StockTicker com o nome da ação fornecido
        
        // TODO: Crie um DayTrader chamado "Alice"
        
        // TODO: Crie um LongTermInvestor chamado "Bob"
        
        // TODO: Inscreva Alice e Bob no ticker
        
        // TODO: Defina o preço como firstPrice (ambos os observadores são notificados)
        
        // TODO: Cancele a inscrição de Alice
        
        // TODO: Defina o preço como secondPrice (apenas Bob é notificado)
        
        scanner.close();
    }
}