Introduzione ai modelli di progettazione

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

I design pattern sono soluzioni comprovate a problemi comuni che gli sviluppatori incontrano ripetutamente durante la creazione di software. Invece di reinventare ogni volta la ruota, puoi applicare questi modelli collaudati nel tempo per risolvere sfide di progettazione ricorrenti.

Considera i design pattern come progetti. Non ti forniscono codice già pronto da copiare e incollare, ma descrivono come strutturare le tue classi e i tuoi oggetti per risolvere un tipo specifico di problema. I pattern che imparerai sfruttano i concetti di OOP che hai già acquisito: ereditarietà, interfacce, polimorfismo e composizione.

I pattern di progettazione rientrano in tre categorie principali:

Categoria	Scopo	Esempi
Creazionali	Come vengono creati gli oggetti	Singleton, Factory, Builder
Strutturali	Come vengono composti gli oggetti	Adapter, Decorator, Composite
Comportamentali	Come comunicano gli oggetti	Observer, Strategy, Command

Perché imparare i pattern di progettazione? Ti forniscono un vocabolario condiviso con gli altri sviluppatori: dire "usa una Factory qui" comunica immediatamente un concetto complesso. Ti aiutano anche a scrivere codice più flessibile e manutenibile, applicando principi come "programma per un'interfaccia, non per un'implementazione".

Nelle prossime lezioni implementerai diversi pattern essenziali, iniziando con i pattern creazionali come Singleton e Factory, per poi passare ai pattern comportamentali come Observer e Strategy.

Sfida

Facile

Costruiamo un semplice classificatore di pattern che dimostri la tua comprensione delle tre categorie di pattern di progettazione! Creerai un sistema che classifica i pattern e ne spiega lo scopo, organizzando il codice in più file.

Creerai tre file:

Pattern.java: crea un'interfaccia chiamata Pattern che definisce il contratto per tutti i pattern di progettazione. La tua interfaccia deve dichiarare due metodi: String getCategory(), che restituisce la categoria del pattern (Creational, Structural o Behavioral), e String getPurpose(), che restituisce una descrizione di ciò che fa quella categoria di pattern.
PatternInfo.java: crea tre classi che implementano la tua interfaccia Pattern, ciascuna rappresentante una categoria di pattern di progettazione:
CreationalPattern - deve restituire "Creational" per la categoria e "How objects are created" per lo scopo.

StructuralPattern - deve restituire "Structural" per la categoria e "How objects are composed" per lo scopo.

BehavioralPattern - deve restituire "Behavioral" per la categoria e "How objects communicate" per lo scopo.
Main.java: metti insieme il tuo classificatore di pattern! Riceverai un input: il nome di un pattern (String), che sarà uno tra "Singleton", "Factory", "Adapter", "Decorator", "Observer" o "Strategy".
In base all'input, crea l'oggetto pattern appropriato:
- "Singleton" e "Factory" sono pattern Creational
- "Adapter" e "Decorator" sono pattern Structural
- "Observer" e "Strategy" sono pattern Behavioral
Memorizza l'oggetto pattern in una variabile di tipo Pattern (l'interfaccia), dimostrando il principio della programmazione orientata alle interfacce. Poi stampa le tre righe seguenti:

Pattern: [input pattern name]

Category: [category from getCategory()]

Purpose: [purpose from getPurpose()]

Riceverai un input: il nome di un pattern di progettazione (String).

Questa sfida rafforza l'intuizione chiave della lezione: i pattern di progettazione sono organizzati in categorie in base al problema che risolvono. Usando un'interfaccia, ti eserciterai anche nel principio «programmare verso un'interfaccia, non verso un'implementazione», un concetto fondamentale che rende i pattern di progettazione così potenti!

Provalo tu

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String patternName = scanner.nextLine();
        
        // TODO: Dichiara una variabile di tipo Pattern (l'interfaccia)
        Pattern pattern = null;
        
        // TODO: In base a patternName, crea l'oggetto pattern appropriato:
        // - "Singleton" e "Factory" sono pattern creazionali
        // - "Adapter" e "Decorator" sono pattern strutturali
        // - "Observer" e "Strategy" sono pattern comportamentali
        
        // TODO: Stampa l'output nel seguente formato:
        // Pattern: [nome del pattern inserito]
        // Category: [categoria restituita da getCategory()]
        // Purpose: [scopo restituito da getPurpose()]
    }
}