Pattern Observer

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

Il Pattern Observer è un pattern comportamentale che stabilisce una relazione uno-a-molti tra oggetti. Quando un oggetto (il soggetto) cambia stato, tutti i suoi dipendenti (gli osservatori) vengono automaticamente avvisati e aggiornati. Pensalo come a un abbonamento a una newsletter: gli iscritti ricevono aggiornamenti ogni volta che viene pubblicato un nuovo contenuto.

Il pattern coinvolge due componenti principali: un soggetto che mantiene un elenco di osservatori e li informa delle modifiche, e osservatori che definiscono un metodo di aggiornamento per rispondere alle notifiche:

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 l’editore pubblica una notizia, tutti gli iscritti vengono avvisati automaticamente:

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

publisher.publish("Breaking news!");
// Output:
// Email a alice@mail.com: Ultime notizie!
// Email a bob@mail.com: Ultime notizie!

Il Pattern Observer promuove un accoppiamento debole: il soggetto non deve conoscere le classi concrete dei suoi osservatori, ma solo sapere che implementano l’interfaccia Observer. Questo rende facile aggiungere nuovi tipi di osservatori senza modificare il soggetto.

Sfida

Facile

Costruiamo un sistema di avvisi sui prezzi delle azioni usando il pattern Observer! Creerai un sistema in cui un ticker azionario notifica più investitori ogni volta che il prezzo di un'azione cambia, consentendo a ciascun investitore di reagire agli aggiornamenti dei prezzi a modo suo.

Organizzerai il codice in quattro file:

Observer.java: Definisci l'interfaccia Observer che tutti gli investitori implementeranno. Dovrebbe dichiarare un unico metodo update(String stockName, double price) che gli osservatori usano per ricevere notifiche sulle variazioni di prezzo.
StockTicker.java: Crea la classe soggetto che mantiene un elenco di osservatori e li notifica delle variazioni di prezzo. Il tuo StockTicker dovrebbe avere:
Un campo String privato per il nome dell'azione (impostato tramite il costruttore).

Un campo double privato per il prezzo corrente (inizialmente 0).

Un elenco privato per memorizzare gli osservatori iscritti.

Un metodo subscribe(Observer observer) che aggiunge un osservatore all'elenco.

Un metodo unsubscribe(Observer observer) che rimuove un osservatore dall'elenco.

Un metodo setPrice(double price) che aggiorna il prezzo e poi notifica tutti gli osservatori chiamando il loro metodo update con il nome dell'azione e il nuovo prezzo.
Investors.java: Crea due diversi tipi di investitori che implementano l'interfaccia Observer:
DayTrader - ha un campo name privato impostato tramite il costruttore. Quando riceve un aggiornamento, stampa [name] received alert: [stockName] is now $[price] - Making quick trade!

LongTermInvestor - ha un campo name privato impostato tramite il costruttore. Quando riceve un aggiornamento, stampa [name] received alert: [stockName] is now $[price] - Holding steady.

Formatta il prezzo con due cifre decimali.
Main.java: Metti insieme il tuo sistema di osservatori! Riceverai tre input: il nome dell'azione (String), il primo aggiornamento del prezzo (double) e il secondo aggiornamento del prezzo (double).
Crea uno StockTicker con il nome dell'azione fornito. Crea un DayTrader chiamato "Alice" e un LongTermInvestor chiamato "Bob", quindi iscrivi entrambi al ticker.

Imposta il prezzo sul valore del primo input (tutti gli osservatori ricevono una notifica). Poi annulla l'iscrizione di Alice. Infine, imposta il prezzo sul valore del secondo input (questa volta dovrebbe ricevere una notifica solo Bob).

Riceverai tre input in questo ordine: nome dell'azione (String), primo prezzo (double), secondo prezzo (double).

Questa sfida dimostra la potenza del pattern Observer: StockTicker non sa nulla dei tipi specifici di investitore. Sa solo che implementano Observer. Quando annulli l'iscrizione di Alice, lei smette di ricevere aggiornamenti mentre Bob continua a essere avvisato. Questo accoppiamento debole rende facile aggiungere nuovi tipi di investitore senza modificare il ticker!

Provalo tu

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Leggi i dati di input
        String stockName = scanner.nextLine();
        double firstPrice = scanner.nextDouble();
        double secondPrice = scanner.nextDouble();
        
        // TODO: Crea un StockTicker con il nome del titolo fornito
        
        // TODO: Crea un DayTrader chiamato "Alice"
        
        // TODO: Crea un LongTermInvestor chiamato "Bob"
        
        // TODO: Iscrivi sia Alice sia Bob al ticker
        
        // TODO: Imposta il prezzo su firstPrice (entrambi gli osservatori ricevono una notifica)
        
        // TODO: Annulla l'iscrizione di Alice
        
        // TODO: Imposta il prezzo su secondPrice (solo Bob riceve una notifica)
        
        scanner.close();
    }
}