Lezioni

Guida pratica alla costruzione di gerarchie di classi in Java: dall’astrazione ai dettagli. Con esempi di figure, mini‑editor, pagamenti e trasporti, mostriamo come estrarre il comune in una classe abstract di base, come sovrascrivere metodi come area()/ draw(), come estendere il sistema senza riscrivere codice ed evitare duplicazioni. Concludiamo con una panoramica degli errori tipici e consigli di progettazione.

Ci esercitiamo ad applicare le astrazioni in scenari reali: pagamenti, trasporti, editor grafico. Mostreremo come estrarre il comportamento comune in una classe base abstract, lavorare tramite un contratto comune e sostituire il codice pieno di if- else con il polimorfismo. Lungo il percorso vedremo come invocare in modo uniforme metodi come process(), move(), draw()/ resize(), in modo che il codice sia flessibile ed estendibile.

Come scomporre applicazioni complesse in livelli di astrazione (UI, logica di business, accesso ai dati) affinché il codice rimanga comprensibile ed estendibile. In pratica costruiamo un mini task‑manager con i layer Task, TaskRepository, TaskService, mostriamo la sostituzione delle implementazioni e i vantaggi per il team. Analizziamo le best practice, gli errori tipici e un esempio con i servizi OrderService/ OrderRepository, nonché metodi come saveOrder() e findUserById().

In questa lezione scoprirai che cos’è un’interfaccia in Java, come dichiararla con la parola chiave interface, come le classi realizzano il contratto tramite implements e perché i metodi, per impostazione predefinita, sono considerati public abstract. Analizzeremo le differenze tra interfaccia e classe, esempi dal JDK ( Comparable, Runnable, Serializable), uno schema visivo ed errori tipici.

In questa lezione confronteremo interfacce e classi astratte in Java: quando scegliere cosa, in cosa differiscono per funzionalità e limitazioni, come appaiono le loro dichiarazioni ( abstract class e interface), cosa significano modificatori come public, abstract, static, e vedremo anche esempi dalla JDK, casi pratici ed errori tipici (ereditarietà, implementazione, uso di implements/ extends).

In questa lezione vediamo come una classe in Java può implementare più interfacce: la sintassi con la parola chiave implements, la combinazione di ruoli (ad esempio, Movable, Attackable, Serializable), firme di metodo coincidenti, assenza del «diamante della morte», e anche cosa fare in caso di conflitti tra metodi default. Sono forniti esempi pratici e un’analisi degli errori tipici.

In questa lezione spieghiamo che cos'è un'interfaccia funzionale (esattamente un solo metodo astratto), come e perché annotarla con @FunctionalInterface, con che cosa è consentito arricchire l'interfaccia tramite default- e static-metodi, e anche come usare tali interfacce nella pratica (classi normali e classi anonime). Esempi con Runnable, Comparator<T> e le interfacce di java.util.function sono accompagnati da una tabella e dall'analisi degli errori più comuni.

Come le interfacce trasformano il codice in un’architettura flessibile: programmiamo contro le astrazioni, iniettiamo dipendenze tramite DI, sostituiamo le implementazioni nei test, aggiungiamo nuovi comportamenti senza modificare il core ( OCP). Analizziamo come le interfacce siano alla base dei pattern Observer, Strategy, Command e mostriamo la pratica con esempi ( UserRepository, NotificationSender, strategie di pagamento).

In questa lezione analizzeremo le espressioni lambda in Java: che cosa sono e a cosa servono, come funziona la sintassi e le scorciatoie, come le lambda sono collegate alle interfacce funzionali ( @FunctionalInterface), in cosa differiscono dalle classi anonime e come funziona la cattura delle variabili ( final / effectively final). Con esempi pratici con Runnable, Consumer, Comparator, Function e Stream API vedremo come scrivere in modo più breve e più chiaro. Concluderemo con la sezione “Errori tipici” e consigli su come evitarli.

Guida rapida ai riferimenti ai metodi in Java: dove e come usare il method reference al posto delle lambda. Vedremo 4 forme: Classe::metodo (statica e “su istanza”), oggetto::metodo, Classe::new. Capiremo la corrispondenza delle firme con le interfacce funzionali, li confronteremo con le espressioni lambda, vedremo esempi pratici con forEach, sort, map e parleremo degli errori tipici (mancata corrispondenza delle firme, overload dei metodi, ecc.).

In questa lezione analizziamo perché in Java 8 sono apparsi i metodi default nelle interfacce, come permettono di evolvere gli API senza rompere il codice esistente, la loro sintassi (parola chiave default prima del tipo di ritorno) e il comportamento nelle implementazioni. Con esempi dalla libreria standard ( List: forEach, replaceAll, sort) vedremo la pratica d’uso. Discuteremo le limitazioni: non si possono sovrascrivere i metodi di Object ( equals/ hashCode/ toString), le regole di risoluzione dei conflitti con implementazioni multiple e gli errori tipici.

Analizziamo come e perché le interfacce in Java hanno ottenuto i static-metodi: sintassi di dichiarazione, differenza rispetto ai metodi default, vincoli chiave (non vengono ereditati, non sono sovrascrivibili, chiamata solo tramite il nome dell’interfaccia, accesso solo ai membri static, supporto di private static da Java 9+). Nella pratica vedremo Movable.resetPosition(), un Logger di supporto, le factory delle collezioni List.of()/ Set.of()/ Map.of() e l’utility Comparator.reverseOrder(). Alla fine — gli errori tipici e come evitarli.