Lezioni

Esaminiamo passo dopo passo come Java inizializza un oggetto: valori predefiniti dei campi, inizializzazione esplicita, blocchi di inizializzazione non statici e chiamata finale del costruttore tramite new. Con l’esempio della classe Person vedremo l’ordine effettivo dell’output, una tabella dei valori di default, un diagramma di flusso e gli errori tipici (duplicazione della logica, aspettative su static, gestione di null, chiamata del costruttore tramite this(...)).

Come trovare un errore senza impazzire. Impariamo a usare il Debugger: breakpoint, esecuzione passo-passo, visualizzazione delle variabili e valutazione delle espressioni al volo.

In questa lezione analizzeremo che cos’è l’incapsulamento in Java, come si realizza con campi privati ( private) e un’interfaccia pubblica (metodi public), perché conviene nascondere lo stato interno degli oggetti e come questo aumenta l’affidabilità e la manutenibilità del codice. Vedrete esempi negativi e positivi, applicazioni pratiche, una tabella di confronto degli approcci ed errori tipici.

In questa lezione analizziamo i livelli di accesso in Java: public, protected, package-private e private. Capiremo dove e perché applicare ciascuno di essi, come proteggere i campi (incapsulamento), quali regole scegliere per metodi e costruttori, vedremo esempi con pacchetti ed ereditarietà, oltre a best practice ed errori tipici.

In questa lezione capirai come, grazie all’incapsulamento e ai metodi get/ set, gestire l’accesso ai campi di una classe in Java. Imparerai le convenzioni JavaBeans, le particolarità per i campi di tipo boolean con i getter isXxx(), vedrai esempi di validazione nei setter, di uso sicuro dei campi mutabili e di generazione automatica dei metodi di accesso nelle IDE.

In questa lezione vedrete come inizializzare i campi static ( static) e i campi immutabili ( final) in Java: al momento della dichiarazione, in un blocco di inizializzazione statico e anche nei costruttori. Parleremo della combinazione di costanti public static final, dell’accesso corretto alla statica, dell’ordine di inizializzazione e degli errori tipici da evitare.

In questa lezione affronterai i blocchi di inizializzazione in Java: in cosa differiscono i blocchi non statici e i blocchi static, in quale ordine vengono eseguiti campi, blocchi e costruttori, quando è opportuno spostare la logica comune nei blocchi e quando è meglio usare i costruttori. Vedremo esempi, sottigliezze dell’ereditarietà ed errori tipici.

Analizziamo le classi interne (non-static inner) in Java: che cosa sono e come sono collegate a un'istanza della classe esterna, come dichiararle e crearle tramite outer. new Inner(), come accedono ai membri con i modificatori private/ public, quali limitazioni esistono (nessun membro static, tranne le costanti), nonché le varianti di visibilità ed esempi pratici: Backpack.Item, un iteratore della propria collezione e il riferimento all'oggetto esterno tramite OuterClassName. this. In chiusura — errori tipici e come evitarli.

Analizziamo le classi annidate statiche in Java: che cosa sono, in cosa si differenziano da quelle interne (inner), come dichiararle tramite il modificatore static, come creare istanze senza un oggetto della classe esterna e quali regole di accesso valgono (niente OuterClass.this, accesso solo ai membri statici). Mostreremo scenari pratici — Builder, nodi interni Node nelle strutture, utility — le confronteremo con le inner class, aggiungeremo un diagramma e analizzeremo gli errori tipici: confusione con outer.new Inner() e la chiamata corretta new Outer.Nested().

In questa lezione analizziamo le classi anonime in Java: cosa sono, come si dichiarano e si creano nel punto d’uso, come il compilatore assegna i nomi ai loro file .class, le limitazioni (final/effectively final, assenza di costruttore, blocchi di inizializzazione) e gli scenari pratici di utilizzo. Mostreremo l’accesso ai membri della classe esterna e analizzeremo gli errori tipici.

Analizziamo le classi locali in Java: cosa sono, come dichiararle all’interno di metodi e blocchi, quali limitazioni si applicano ai modificatori e ai membri statici, e come funziona l’accesso alle variabili del metodo (solo final/ effectively final). Confronteremo con le classi anonime, vedremo esempi pratici (comparatore, struttura dati temporanea, mini‑risultato di test) ed errori tipici. Capirai quando una classe locale è più adatta di una anonima e perché ricordarsi di static e di public/ private/ protected.

Introduzione pratica ai Generics (tipi generici) in Java: perché conservare in Object è rischioso, come dichiarare classi e metodi generici, come usare Box<T>, le coppie e i metodi generici, e quali vantaggi offre la sicurezza di tipo senza cast espliciti. Discuteremo le limitazioni (tipi primitivi, type erasure) ed esamineremo esempi d’uso.