Programmazione Java: Guida ai Concetti Fondamentali

Java è uno dei linguaggi di programmazione più diffusi e longevi nel panorama dello
sviluppo software, creato da James Gosling e rilasciato da Sun Microsystems (oggi
Oracle) nel 1995. La sua filosofia originaria, riassunta nel motto "write once, run
anywhere" (scrivi una volta, esegui ovunque), lo ha reso una scelta privilegiata per
applicazioni enterprise, sistemi Android, backend web e molto altro. Vediamo insieme i
concetti più importanti che ogni programmatore Java dovrebbe conoscere.

La Java Virtual Machine e la portabilità

Il concetto fondante di Java è la Java Virtual Machine (JVM). Quando scrivi codice Java, il
compilatore (javac) non lo traduce direttamente in codice macchina nativo, ma in un
formato intermedio chiamato bytecode, contenuto in file con estensione .class. Questo
bytecode viene poi eseguito dalla JVM, che si occupa di interpretarlo o compilarlo just-
in-time (JIT) per il processore specifico su cui gira. Questo è il motivo per cui lo stesso
programma Java può funzionare su Windows, Linux, macOS o qualsiasi altro sistema
dotato di una JVM compatibile, senza bisogno di ricompilazione.

Oltre alla JVM, è importante conoscere altri due acronimi: il JRE (Java Runtime
Environment), che include la JVM più le librerie standard necessarie per eseguire
applicazioni Java, e il JDK (Java Development Kit), che comprende il JRE più gli strumenti
di sviluppo come il compilatore, il debugger e altre utility. Per programmare in Java è
necessario installare il JDK.

Sintassi di base e tipi di dato

Java è un linguaggio fortemente tipizzato e a tipizzazione statica: ogni variabile deve

avere un tipo dichiarato esplicitamente e questo tipo non può cambiare durante
l'esecuzione. I tipi si dividono in due grandi categorie: i tipi primitivi e i tipi riferimento.

I tipi primitivi sono otto: byte, short, int, long (per i numeri interi con diverse dimensioni
in bit), float e double (per i numeri decimali), char (per i singoli caratteri Unicode) e
boolean (per i valori vero/falso). Questi tipi non sono oggetti e vengono memorizzati
direttamente nello stack, garantendo prestazioni elevate.

I tipi riferimento includono tutto il resto: classi, interfacce, array ed enum. Una variabile
di tipo riferimento non contiene direttamente il valore, ma un riferimento
(concettualmente simile a un puntatore, anche se Java non permette l'aritmetica dei
puntatori) all'oggetto memorizzato nello heap.

Un aspetto interessante è l'autoboxing e unboxing: Java fornisce classi wrapper per ogni
tipo primitivo (Integer, Double, Boolean, Character, ecc.) che permettono di trattare i
valori primitivi come oggetti quando necessario, ad esempio per inserirli in una
collezione, con conversioni automatiche gestite dal compilatore.

Programmazione orientata agli oggetti

Java è progettato attorno al paradigma della programmazione orientata agli oggetti
(OOP), e i suoi quattro pilastri sono essenziali per comprendere il linguaggio.

Incapsulamento: consiste nel nascondere i dettagli implementativi di una classe e

nell'esporre solo ciò che è necessario attraverso un'interfaccia pubblica ben definita. In
pratica, si dichiarano i campi come privati (private) e si forniscono metodi pubblici
(getter e setter) per accedervi in modo controllato. Questo protegge l'integrità dei dati e
permette di modificare l'implementazione interna senza rompere il codice che usa la
classe.

Ereditarietà: permette a una classe (sottoclasse o classe figlia) di ereditare campi e

metodi da un'altra classe (superclasse o classe padre), tramite la parola chiave extends.
Questo favorisce il riutilizzo del codice ed esprime relazioni "è un" (is-a), ad esempio una
classe Cane potrebbe estendere una classe Animale. Java supporta solo l'ereditarietà
singola tra classi (una classe può estendere una sola superclasse), ma permette
l'implementazione di più interfacce contemporaneamente.

Polimorfismo: permette a oggetti di classi diverse di essere trattati attraverso

un'interfaccia comune. Si manifesta principalmente in due forme: il polimorfismo di
overriding (o a runtime), dove una sottoclasse ridefinisce un metodo ereditato con
l'annotazione @Override, e il polimorfismo di overloading (o a compile-time), dove più
metodi nella stessa classe condividono lo stesso nome ma hanno parametri diversi per
tipo o numero.

Astrazione: consiste nel definire concetti generali senza specificarne i dettagli

implementativi. In Java questo si realizza tramite classi astratte (abstract class) e
interfacce (interface). Una classe astratta non può essere istanziata direttamente e può
contenere sia metodi concreti che astratti (senza implementazione, da completare nelle
sottoclassi). Un'interfaccia, invece, definisce un contratto di metodi che le classi
implementanti devono rispettare; dalla versione 8 di Java, le interfacce possono
contenere anche metodi con implementazione di default (default methods) e metodi
statici.

Classi, oggetti e costruttori

Una classe è un progetto (blueprint) da cui vengono creati gli oggetti. Contiene campi
(variabili di istanza) che rappresentano lo stato dell'oggetto, e metodi che rappresentano
il suo comportamento. Un oggetto è un'istanza concreta di una classe, creata tramite
l'operatore new, che alloca memoria nello heap e invoca un costruttore.

Il costruttore è un metodo speciale con lo stesso nome della classe, privo di tipo di
ritorno, invocato automaticamente alla creazione dell'oggetto per inizializzarne lo stato.
Se non se ne definisce uno esplicitamente, Java fornisce un costruttore di default senza
parametri. È possibile definire più costruttori con parametri diversi (overloading dei
costruttori) e utilizzare la parola chiave this per invocare un altro costruttore della stessa
classe, o super per invocare il costruttore della superclasse.

Modificatori di accesso e altre parole chiave

I modificatori di accesso controllano la visibilità di classi, metodi e campi: public

(accessibile da ovunque), protected (accessibile nello stesso package e dalle
sottoclassi), nessun modificatore o "package-private" (accessibile solo nello stesso
package), e private (accessibile solo all'interno della stessa classe).

Altre parole chiave fondamentali includono static, che indica che un membro appartiene
alla classe piuttosto che alle singole istanze (esiste un'unica copia condivisa), final, che
rende una variabile non riassegnabile (una costante), un metodo non sovrascrivibile, o
una classe non estendibile, e abstract, per classi e metodi astratti come già visto.

Gestione delle eccezioni

Java gestisce gli errori a runtime attraverso un robusto sistema di eccezioni.

Un'eccezione è un oggetto che rappresenta una condizione anomala verificatasi durante
l'esecuzione. La gerarchia parte dalla classe Throwable, da cui derivano Error (problemi
gravi del sistema, generalmente non gestibili, come OutOfMemoryError) ed Exception.

Le eccezioni si dividono in checked (verificate) e unchecked (non verificate). Le checked

exception, come IOException, devono essere obbligatoriamente gestite con un blocco
try-catch o dichiarate nella firma del metodo con throws, pena un errore di
compilazione. Le unchecked exception, sottoclassi di RuntimeException come
NullPointerException o ArrayIndexOutOfBoundsException, non richiedono questa
gestione esplicita, anche se è comunque buona pratica prevenirle.

La struttura tipica è:

try {

// codice che potrebbe lanciare un'eccezione

} catch (SpecificException e) {

// gestione dell'eccezione

} finally {

// codice sempre eseguito, utile per il rilascio di risorse

Dalla versione 7 esiste anche il try-with-resources, che chiude automaticamente le

risorse (come stream o connessioni) che implementano l'interfaccia AutoCloseable.

Collezioni (Collections Framework)

Il Java Collections Framework è un insieme unificato di interfacce e classi per gestire
gruppi di oggetti. Le interfacce principali sono:

List: una collezione ordinata che ammette duplicati, con implementazioni come
ArrayList (basata su array dinamico, accesso rapido per indice) e LinkedList (basata su
lista concatenata, inserimenti e rimozioni efficienti).

Set: una collezione che non ammette duplicati, con implementazioni come HashSet
(non ordinato, basato su tabella hash), LinkedHashSet (mantiene l'ordine di inserimento)
e TreeSet (mantiene un ordinamento naturale o personalizzato tramite Comparator).

Map: rappresenta un'associazione chiave-valore (non è tecnicamente una Collection ma

fa parte del framework), con implementazioni come HashMap, LinkedHashMap e
TreeMap, analoghe per comportamento ai rispettivi Set.

Queue e Deque: rappresentano rispettivamente code (FIFO) e code a doppia entrata, con
implementazioni come LinkedList e ArrayDeque.

Dalla versione 5, Java supporta i generics, che permettono di parametrizzare i tipi delle
collezioni (ad esempio List<String> invece di una lista non tipizzata), garantendo
sicurezza a compile-time ed evitando cast espliciti e potenziali ClassCastException a
runtime.

Programmazione funzionale: lambda e Stream API

Con Java 8 è stata introdotta una svolta importante verso la programmazione funzionale.
Le espressioni lambda permettono di scrivere implementazioni concise di interfacce
funzionali (interfacce con un solo metodo astratto), come Runnable, Comparator o le
interfacce del package [Link] (Function, Predicate, Supplier, Consumer). La
sintassi tipica è:

(parametri) -> espressione_o_blocco

Ad esempio, ordinare una lista di stringhe per lunghezza si può scrivere come:

[Link]((a, b) -> [Link]() - [Link]());

La Stream API, sempre introdotta in Java 8, permette di elaborare collezioni di dati in

modo dichiarativo, componendo operazioni intermedie (come filter, map, sorted) e
operazioni terminali (come collect, forEach, reduce). Ad esempio:

List<String> risultato = [Link]()

.filter(p -> [Link]() > 18)

.map(Persona::getNome)

.sorted()

.collect([Link]());
Questo stile di programmazione favorisce codice più leggibile, meno soggetto a errori e
potenzialmente parallelizzabile (tramite parallelStream()).

Gestione della memoria e Garbage Collector

Una delle caratteristiche distintive di Java rispetto a linguaggi come C o C++ è la gestione
automatica della memoria tramite il Garbage Collector (GC). Il programmatore non deve
preoccuparsi di deallocare manualmente la memoria: il GC identifica periodicamente gli
oggetti non più raggiungibili (senza riferimenti attivi) e ne libera lo spazio nello heap.
Questo elimina intere categorie di bug comuni in altri linguaggi, come i memory leak
dovuti a deallocazioni mancate o i dangling pointer, anche se richiede attenzione a
possibili perdite di memoria "logiche" (ad esempio riferimenti mantenuti inutilmente in
collezioni statiche).

La memoria in Java si divide principalmente in stack (per le variabili locali e i riferimenti,

con gestione LIFO e allocazione/deallocazione automatica alla fine dello scope) e heap
(dove risiedono tutti gli oggetti, gestito dal GC).

Concorrenza e multithreading

Java offre un supporto nativo e maturo per la programmazione concorrente. Un thread

rappresenta un flusso di esecuzione indipendente all'interno di un processo. Si può
creare estendendo la classe Thread o, più comunemente, implementando l'interfaccia
Runnable (o Callable, se si necessita di un valore di ritorno) e passandola a un thread o a
un executor.

La parola chiave synchronized permette di definire blocchi di codice o metodi che

possono essere eseguiti da un solo thread alla volta su un dato oggetto, prevenendo race
condition su risorse condivise. Il package [Link] fornisce strumenti più
sofisticati e performanti, come gli ExecutorService per gestire pool di thread, le classi
Atomic (AtomicInteger, ecc.) per operazioni atomiche senza lock espliciti, e le collezioni
thread-safe come ConcurrentHashMap.

Le innovazioni delle versioni recenti

Java si è evoluto molto negli ultimi anni, con un ciclo di rilascio semestrale a partire dalla
versione 9. Alcune novità rilevanti includono i record (Java 14+), classi immutabili
concise pensate per il semplice trasporto di dati, che generano automaticamente
costruttore, getter, equals, hashCode e toString:

record Punto(int x, int y) {}

Il pattern matching per instanceof (Java 16+) semplifica i controlli e i cast di tipo, mentre
le sealed classes (Java 17+) permettono di restringere quali classi possono estendere o
implementare una determinata classe o interfaccia, offrendo maggiore controllo sulle
gerarchie di tipo. Gli switch expressions (Java 14+) hanno reso il costrutto switch più
espressivo e meno soggetto a errori, eliminando il fall-through implicito quando si usa la
nuova sintassi con freccia.

Conclusione

Java rimane un linguaggio estremamente rilevante nel panorama tecnologico attuale,

grazie a un equilibrio tra solidità, prestazioni, un ecosistema vastissimo di librerie e
framework (Spring, Hibernate, tra i più diffusi) e una comunità di sviluppatori enorme.
Comprendere a fondo i concetti qui illustrati — dalla JVM ai principi OOP, dalla gestione
delle eccezioni alle collezioni, fino alla programmazione funzionale e alla concorrenza —
costituisce una base solida per affrontare qualsiasi progetto di sviluppo software in
questo linguaggio, sia esso un'applicazione desktop, un servizio web enterprise o un
sistema distribuito su larga scala.

Se vuoi, posso approfondire uno di questi argomenti con esempi di codice più estesi,
oppure aiutarti a impostare un progetto Java pratico.