Lezioni

In questa lezione analizzeremo che cos’è l’ereditarietà in Java, come usarla per evitare la duplicazione del codice e come dichiarare gerarchie tramite la parola chiave extends. Vedremo che cosa eredita esattamente una sottoclasse, quali sono le limitazioni (ereditarietà singola, membri privati, costruttori), esamineremo un esempio pratico con gli animali, alcune sfumature legate ai costruttori e gli errori tipici.

In questa lezione analizziamo la ridefinizione dei metodi in Java: come e perché una sottoclasse sostituisce il comportamento del genitore, a cosa serve l'annotazione @Override, come funziona il polimorfismo quando si invoca tramite un riferimento di tipo base, nonché le regole chiave (firma, modificatori di accesso, eccezioni, covarianza) e le limitazioni ( static, final, private). Concludiamo con la pratica su un mini‑progetto «Zoo» e con l'analisi degli errori tipici.

Analizziamo la parola chiave super in Java: come chiamare metodi e costruttori della classe base, come accedere ai campi nascosti del genitore, quando e perché estendere il comportamento tramite super e super(...), nonché le limitazioni (non si può usare nei metodi statici, niente accesso a private) e gli errori tipici. Molti esempi pratici su gerarchie Animal/ Cat/ Dog e Vehicle/ Car.

Impareremo a progettare e implementare gerarchie di classi in Java: come distinguere tra generale e specifico, costruire l’albero di ereditarietà, dove è appropriata la relazione is-a e quando è meglio usare la composizione ( has-a). Vedremo esempi concreti (animali, geometria, trasporti, utenti), sottigliezze architetturali ed errori tipici di progettazione.

In questa lezione discutiamo i limiti del modello di ereditarietà in Java: ereditarietà singola delle classi, assenza di ereditarietà dei costruttori e inaccessibilità dei membri private. Analizzeremo gerarchie «fragili» e l’effetto di un’ereditarietà «che si rompe», mostreremo alternative — composizione ( has-a), delegazione e interfacce, nonché i criteri «quando serve davvero extends». Lungo il percorso noteremo la chiamata al costruttore del genitore tramite super(...) e gli errori di progettazione tipici.

In questa lezione analizziamo il polimorfismo in Java: che cos’è, in cosa differiscono overloading e overriding, come funziona il binding tardivo e perché un’interfaccia può avere molte implementazioni. Con esempi pratici vedremo come il polimorfismo semplifica l’architettura, rende il codice estendibile e riduce l’accoppiamento tra moduli.

Immergiamoci nel sovraccarico dei metodi in Java: quando ha senso dichiarare più versioni dello stesso metodo, come il compilatore sceglie la corrispondenza migliore in base ai parametri, perché non si può sovraccaricare solo in base al tipo di ritorno e come funzionano i costruttori sovraccaricati e ... varargs. Analizzeremo esempi con println, creeremo un piccolo Calculator e passeremo in rassegna gli errori tipici legati alla conversione automatica e alle ambiguità tra Integer/ Long.

Analizziamo in dettaglio l’override dei metodi in Java: come l’overriding garantisce il polimorfismo durante l’esecuzione, in cosa si differenzia dall’ overloading, quali regole valgono (firme, accesso, eccezioni, covarianza), come usare @Override e invocare la logica del genitore tramite super. Mostreremo esempi pratici e affronteremo gli errori tipici.

Mostriamo il polimorfismo con esempi concreti: come memorizzare oggetti eterogenei in un’unica collezione del tipo base e chiamare i metodi «corretti» senza if/ switch, come l’aggiunta di una nuova sottoclasse non richiede di riscrivere la logica e quali sono i limiti dell’approccio. Costruiremo una gerarchia di dipendenti con il metodo work(), parleremo di estendibilità e analizzeremo gli errori tipici.

Come le classi e i metodi astratti definiscono un contratto comune e abilitano il polimorfismo in Java: perché non si può creare un oggetto astratto, come i sottotipi implementano i metodi obbligatori, come lavorare tramite il tipo base ottenendo al contempo il comportamento «corretto». Vedremo esempi con animali e una gerarchia di dipendenti, sfumature di sintassi ed errori tipici.

Un'introduzione chiara all'astrazione nella programmazione a oggetti in Java: che cos'è, a cosa serve e come applicarla nella progettazione. Analizzeremo gli strumenti del linguaggio — classi astratte abstract class e interfacce interface, metodi astratti e il lavoro tramite un contratto comune (ad esempio, chiamate come payment.process() o draw()). Con esempi pratici ( Shape, Payment, Transport) mostreremo come nascondere i dettagli dell'implementazione, ridurre l'accoppiamento e semplificare l'estensione del sistema.

In questa lezione analizziamo passo dopo passo le classi e i metodi astratti in Java: quando serve abstract, come dichiarare una class astratta, in cosa differisce da un interface e come implementare i metodi obbligatori (per esempio, makeSound()) nelle sottoclassi. Accompagneremo la teoria con esempi pratici ( Animal, Transport, Shape) e passeremo in rassegna gli errori tipici: dal tentativo di creare un’istanza di una classe astratta all’uso scorretto dei modificatori.