Quali compiti hai risolto utilizzando pattern di…

Ha applicato vari pattern per migliorare la struttura e la manutenibilità del codice:

Creazionali:

Singleton: Per creare un'unica istanza di oggetti, ad esempio, un gestore di configurazione o un pool di connessioni al database.

public final class ConfigManager {
    private static ConfigManager instance;
    private ConfigManager() {} // Costruttore privato
    public static synchronized ConfigManager getInstance() {
        if (instance == null) {
            instance = new ConfigManager();
        }
        return instance;
    }
}

Factory Method: Per creare oggetti con proprietà specifiche senza indicare esplicitamente le classi concrete. È stato usato nel lavoro con diversi tipi di parser di file.
Abstract Factory: Per creare famiglie di oggetti correlati o dipendenti senza indicare le loro classi concrete. È stato applicato nel lavoro con diversi tipi di fonti di dati (ad esempio, file system, database) e i loro oggetti corrispondenti.

Strutturali:

Adapter: Per adattare l'interfaccia di una classe a un'altra che il cliente si aspetta. È stato usato per integrare librerie di terze parti con interfacce incompatibili.

public interface Target {
    void request();
}

public class Adaptee {
    public void specificRequest() {
        System.out.println("Richiesta specifica di Adaptee");
    }
}

public class Adapter implements Target {
    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void request() {
        adaptee.specificRequest();
    }
}

Decorator: Per aggiungere dinamicamente nuove responsabilità agli oggetti senza modificarne la struttura. È stato usato per aggiungere funzionalità di logging o caching agli oggetti esistenti.
Composite: Per comporre oggetti in strutture ad albero per rappresentare gerarchie "parte-tutto". È usato nel lavoro con elementi dell'interfaccia utente o strutture di file.

Comportamentali:

Observer: Per definire una dipendenza "uno-a-molti" tra oggetti in modo che, quando cambia lo stato di uno, tutti quelli dipendenti siano notificati e aggiornati automaticamente. È stato usato per implementare sistemi di notifica di eventi.

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

public class Subject {
    private List<Observer> observers = new ArrayList<>();
    private int state;

    public void attach(Observer observer) {
        observers.add(observer);
    }

    public void setState(int state) {
        this.state = state;
        notifyObservers();
    }

    private void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

public interface Observer {
    void update();
}

Strategy: Per definire famiglie di algoritmi, incapsulando ciascuno di essi e garantendo la loro intercambiabilità. È stato usato per scegliere diverse strategie di elaborazione dei dati in base al contesto.
Template Method: Per definire lo scheletro di un algoritmo in un'operazione, lasciando alcuni passi alle sottoclassi. È stato applicato per standardizzare il processo di gestione delle richieste.

Quali compiti hai risolto utilizzando pattern di progettazione?