Java è un linguaggio di programmazione general purpose, basato principalmente sulle classi e con tipizzazione statica. Nasce nella prima metà degli anni Novanta e, dopo decenni di evoluzione, continua a essere utilizzato soprattutto nello sviluppo backend, nelle applicazioni enterprise e in numerosi sistemi costruiti attorno alla Java Virtual Machine.
Questa definizione, però, spiega solo una parte del motivo per cui Java è ancora rilevante.
Quando si parla di linguaggio Java, infatti, è facile confondere almeno quattro elementi diversi: il linguaggio con cui si scrive il codice, il bytecode prodotto dalla compilazione, la JVM che lo esegue e il JDK che fornisce gli strumenti per sviluppare. A complicare le cose ci sono poi concetti storici come JRE, applet e plugin Java, che molte guide continuano a presentare come se descrivessero l’ecosistema attuale.
Capire Java oggi significa quindi partire dal suo modello di esecuzione. Una volta chiaro il percorso codice sorgente → bytecode → JVM, diventano molto più semplici anche domande come a cosa serve Java, quale JDK installare, che differenza c’è con JavaScript e perché una versione più recente non coincide necessariamente con quella più adatta a un progetto.
Cos’è Java: linguaggio, piattaforma ed ecosistema
Java nasce come linguaggio di programmazione, ma nel tempo il nome è diventato anche un riferimento a un ecosistema molto più ampio.
Questa distinzione conta. Dire semplicemente “Java è un linguaggio” è corretto, ma non basta a spiegare perché lo stesso programma possa essere eseguito su sistemi differenti, perché esistano varie distribuzioni del JDK o perché tecnologie come Kotlin possano interagire con lo stesso ambiente JVM.
Il linguaggio Java e le sue caratteristiche fondamentali
Java è un linguaggio general purpose, quindi non è progettato esclusivamente per un’unica categoria di software. È fortemente e staticamente tipizzato: il tipo di variabili, parametri e valori viene controllato secondo regole definite dal linguaggio e molti errori possono emergere già durante la compilazione.
Il modello è principalmente class-based e supporta la programmazione orientata agli oggetti, con concetti come classi, oggetti, ereditarietà, interfacce e incapsulamento. Questo non significa che “in Java tutto sia un oggetto”: il linguaggio dispone, per esempio, anche di tipi primitivi come int, boolean e double.
Una caratteristica centrale è inoltre la gestione automatica della memoria. Normalmente non sei tu a liberare manualmente ogni area di memoria che non serve più: la JVM dispone di garbage collector che individuano gli oggetti non più raggiungibili e possono recuperarne lo spazio.
Java include anche un sistema maturo di eccezioni, concorrenza, librerie standard e strumenti di sviluppo. Nessuna di queste caratteristiche, presa isolatamente, spiega però il successo del linguaggio. Il punto più importante è il modo in cui il codice viene trasformato ed eseguito.
Perché Java non è soltanto un linguaggio di programmazione
Quando scrivi Java crei normalmente file con estensione .java. Quel codice non viene semplicemente trasformato in un eseguibile nativo legato direttamente a Windows, macOS o Linux.
Il compilatore produce invece un formato intermedio chiamato bytecode, normalmente contenuto nei file .class. Quel bytecode viene poi caricato ed eseguito da una Java Virtual Machine compatibile.
È questo livello intermedio che permette a Java di separare in buona parte il codice applicativo dal sistema operativo sottostante.
Per questo “Java” viene usato spesso anche per indicare una piattaforma: attorno al linguaggio esistono JVM, API standard, strumenti, librerie, framework, sistemi di build e diverse distribuzioni del JDK.
Il vantaggio pratico è importante, ma va formulato correttamente. La portabilità non significa che qualsiasi applicazione Java funzioni automaticamente ovunque senza verifiche. Codice nativo, dipendenze esterne, filesystem, configurazioni, architettura hardware e componenti specifici del sistema possono comunque introdurre vincoli.
Come funziona Java: dal codice sorgente alla JVM
Il modo più utile per capire Java è seguire un programma durante il suo percorso.
La documentazione introduttiva di Dev.java descrive lo stesso ciclo di base: scrivi il sorgente, lo compili e poi esegui il risultato attraverso gli strumenti della piattaforma Java.
Dalla compilazione al bytecode
Supponiamo di avere questo file:
public class HelloJava {
public static void main(String[] args) {
System.out.println("Ciao, Java!");
}
}
Il file può essere salvato come:
HelloJava.java
Con il compilatore javac puoi trasformarlo in bytecode:
javac HelloJava.java
Se la compilazione termina correttamente, viene prodotto:
HelloJava.class
Il .class non contiene il sorgente Java originale. Contiene istruzioni nel formato previsto dalla piattaforma Java.
A questo punto puoi eseguire la classe con:
java HelloJava
Il percorso concettuale è quindi:
HelloJava.java
↓
javac
↓
HelloJava.class
↓
JVM
↓
esecuzione sul sistema
Da Java 11 esiste anche la possibilità di eseguire direttamente un file sorgente in alcuni scenari con il launcher java, evitando di mostrare come passaggio separato il comando javac. Per capire il meccanismo, però, il flusso classico resta più istruttivo perché rende visibile la separazione tra sorgente, compilazione e bytecode.
Java Virtual Machine: cosa fa la JVM
La Java Virtual Machine è la macchina astratta che definisce l’ambiente nel quale viene eseguito il codice Java compilato.
Capire il ruolo della Java Virtual Machine è fondamentale perché è proprio questo livello a separare il bytecode dal sistema operativo sul quale l’applicazione viene eseguita.
La JVM non è semplicemente un “programma che legge Java”. Riceve class file conformi al formato previsto dalla piattaforma, carica le classi necessarie, verifica il bytecode, gestisce aree di memoria e runtime e coordina l’esecuzione.
Le implementazioni moderne possono inoltre compilare parti del bytecode in codice macchina durante l’esecuzione. È uno dei motivi per cui la contrapposizione “Java è compilato o interpretato?” è poco utile se presentata come una scelta binaria.
Java ha un compilatore che produce bytecode. La JVM può poi usare differenti strategie per eseguirlo, comprese tecniche di compilazione just-in-time e, nelle implementazioni moderne, altre ottimizzazioni runtime.
Un’altra distinzione importante è che JVM e Java non sono sinonimi. Java è un linguaggio; la JVM è una piattaforma di esecuzione. Altri linguaggi, come Kotlin o Scala, possono produrre codice destinato alla JVM.
JDK, JRE e JVM: differenze e cosa serve davvero
JDK, JRE e JVM vengono spesso descritti come tre versioni dello stesso software. Non lo sono.
| Componente | Che cos’è | A cosa serve | Cosa significa oggi |
|---|---|---|---|
| JVM | Java Virtual Machine | esegue il bytecode e gestisce il runtime | è il livello di esecuzione, non il kit con cui programmi |
| JDK | Java Development Kit | compilare, eseguire, testare e sviluppare applicazioni Java | è normalmente ciò che installa uno sviluppatore |
| JRE | Java Runtime Environment | ambiente destinato alla sola esecuzione | resta un concetto importante, ma Oracle/OpenJDK non distribuiscono più un JRE separato moderno come normale download per sviluppatori |
Il JDK contiene gli strumenti di sviluppo. Tra questi trovi javac, il launcher java e molte altre utility.
Il JRE rappresenta invece storicamente il sottoinsieme necessario a eseguire applicazioni senza fornire l’intero ambiente di sviluppo. Nella distribuzione moderna il confine è meno visibile all’utente: come spiega Dev.java, per iniziare a sviluppare si scarica normalmente un JDK.
Esiste ancora una superficie consumer legata a Java 8 su Java.com, ma non va confusa con il modo in cui oggi si prepara un ambiente di sviluppo Java moderno.
In pratica, se vuoi programmare in Java, la domanda utile non è “devo installare la JVM o il JRE?”. Ti serve un JDK adatto al progetto. La JVM necessaria fa parte del runtime fornito dalla distribuzione.
A cosa serve Java oggi
Per capire davvero a cosa serve Java, conviene guardare ai contesti in cui viene utilizzato oggi invece di fermarsi agli esempi storici legati al browser.
L’associazione con applet e piccoli programmi eseguiti nel browser può far sembrare Java una tecnologia del Web degli anni Novanta. L’ecosistema attuale è molto diverso.
Il linguaggio continua a essere usato soprattutto dove contano codebase di lunga durata, ecosistemi maturi, tooling, compatibilità e infrastrutture server.
Backend, API e applicazioni enterprise
Uno dei principali casi d’uso di Java è lo sviluppo lato server.
Può essere impiegato per costruire API, servizi, applicazioni aziendali, sistemi distribuiti e backend che gestiscono logica, dati, autenticazione e integrazioni.
Framework ed ecosistemi come Spring hanno contribuito a rendere Java molto presente in questo ambito, ma è utile separare il linguaggio dal framework: imparare Java non equivale a imparare Spring e conoscere Spring senza comprendere HTTP, dati, concorrenza e architettura non sostituisce le basi.
Se vuoi capire dove si colloca il linguaggio all’interno di un’applicazione web, la guida al backend segue il percorso completo dalla richiesta del client alla logica server e alla risposta.
Java tende ad avere senso soprattutto quando il progetto beneficia di un ecosistema consolidato, di librerie mature, di strumenti di analisi e debugging evoluti e di un modello di sviluppo fortemente tipizzato.
Non significa che sia “il miglior linguaggio backend”. Node.js, .NET, Go, Python e altri stack possono rispondere allo stesso problema con compromessi differenti.
Java su Android: il ruolo attuale accanto a Kotlin
Java ha avuto un ruolo fondamentale nello sviluppo Android e continua a essere presente in moltissime codebase, librerie e API. Per un nuovo progetto, però, descrivere Android semplicemente come “programmazione Java per smartphone” sarebbe ormai fuorviante.
Google ha spostato da anni molta parte dell’esperienza di sviluppo verso Kotlin, che mantiene una forte interoperabilità con Java. La documentazione Kotlin per Android riflette questa direzione.
C’è poi una precisazione tecnica importante: un’app Android non segue esattamente il modello “file .class eseguito dalla normale JVM desktop/server”. Il processo di build converte il codice verso il formato DEX e Android utilizza il proprio runtime, ART.
Per questo Java su Android va considerato dentro l’ecosistema Android, non come una semplice replica della Java SE installata su un computer.
Se il tuo obiettivo è diventare Android Developer, oggi partirei da Kotlin e tratterei Java come una competenza complementare molto utile per leggere e mantenere software esistente, interoperare con librerie e comprendere una parte importante della storia e dell’ecosistema della piattaforma.
Applicazioni desktop e altri ecosistemi Java
Java può essere usato anche per software desktop, strumenti da riga di comando, applicazioni interne e numerose piattaforme che ruotano attorno alla JVM.
Un dettaglio utile per evitare un altro equivoco storico: JavaFX non è più incluso nel JDK. Dal JDK 11 viene distribuito separatamente. Quindi “Java supporta applicazioni desktop” non significa che ogni componente grafico moderno sia automaticamente contenuto nel kit base.
La JVM è inoltre diventata un ecosistema che va oltre Java stesso. Linguaggi diversi possono convivere nello stesso progetto o utilizzare librerie compatibili con la piattaforma.
Questo è un vantaggio importante nei sistemi di lunga durata: la scelta del linguaggio resta importante, ma non coincide necessariamente con la scelta dell’intero ecosistema runtime.
Java nel 2026: versioni attuali e tecnologie diventate legacy
Java segue un ciclo di rilascio regolare. Per questo una guida che cita genericamente “l’ultima versione” invecchia velocemente, mentre alcuni concetti restano stabili per anni.
Al 29 settembre 2026, il quadro corrente distingue chiaramente release più recente e versione LTS.
Java 27 e JDK 25 LTS: latest release e LTS non sono la stessa cosa
La pagina ufficiale dei download Java di Oracle indica JDK 27 come release più recente della piattaforma Java SE e JDK 25 come release Long-Term Support più recente. JDK 21 è la LTS precedente.
Questa differenza risponde a due esigenze diverse.
Una feature release recente permette di utilizzare prima le novità della piattaforma e segue il normale ciclo semestrale. Una LTS è invece inserita in un orizzonte di supporto più lungo.
Per questo “quale versione devo installare?” non si risolve automaticamente scegliendo il numero più alto.
Se stai semplicemente studiando e vuoi osservare lo stato più recente della piattaforma, JDK 27 è una scelta coerente. Se stai iniziando un progetto che privilegia stabilità del supporto e compatibilità con un ecosistema già definito, JDK 25 LTS è spesso il punto di partenza più conservativo.
La decisione finale deve comunque tenere conto delle versioni supportate da framework, librerie, build system e ambiente di produzione. La roadmap Java SE di Oracle è la fonte da ricontrollare quando il support lifecycle è materialmente importante.
Oracle JDK e OpenJDK: la distinzione da conoscere
“JDK” non identifica una sola distribuzione.
OpenJDK è l’implementazione open source di riferimento dell’ecosistema Java SE, mentre Oracle distribuisce propri build Oracle JDK. Esistono inoltre distribuzioni mantenute da altri vendor e organizzazioni.
Per uno sviluppatore questa distinzione ha due conseguenze.
La prima è tecnica: distribuzione, aggiornamenti, pacchetti, supporto e alcune caratteristiche operative possono variare.
La seconda è di licensing e supporto. Non conviene quindi riassumere il tema con la frase “Java è gratis” senza indicare a quale build e versione ci si riferisca.
La FAQ ufficiale sulle licenze Oracle JDK distingue, tra le altre cose, gli OpenJDK build di Oracle distribuiti sotto GPLv2 con Classpath Exception dalle condizioni NFTC applicate alle release Oracle JDK indicate.
Per imparare il linguaggio non serve trasformare il licensing nel primo problema da risolvere. Per un utilizzo aziendale o in produzione, invece, versione, distribuzione, condizioni d’uso e supporto vanno verificati sul caso reale.
Applet, plugin browser e Java Web Start: cosa non rappresenta più Java moderno
Questa è una delle correzioni più importanti rispetto a molte spiegazioni storiche di Java.
Per anni Java è stato associato a programmi e applet eseguiti attraverso plugin del browser. Quell’ecosistema di deployment non descrive più la piattaforma corrente.
Oracle documenta nella Migration Guide di JDK 11 la rimozione dello stack di deployment che comprendeva Java Plug-in, Applet Viewer, Java Web Start e Java Control Panel.
La transizione è proseguita: in JDK 26 è stata rimossa anche l’Applet API dalla piattaforma, come riportato nelle modifiche significative di JDK 26.
Quindi, se trovi una guida che presenta le applet come uno dei modi principali in cui “Java funziona sul Web”, stai leggendo un modello storico.
Java rimane molto utilizzato in sistemi che comunicano attraverso il Web, ma soprattutto dietro l’interfaccia: servizi backend, API, applicazioni enterprise e infrastrutture. Non attraverso un plugin Java dentro una normale pagina web moderna.
Java vs JavaScript: le differenze che contano davvero
Il nome simile è una delle fonti di confusione più persistenti per chi inizia.
Java vs JavaScript non è il confronto tra una versione completa e una versione “script” della stessa tecnologia. Sono linguaggi differenti, con storie, sistemi di tipi, modelli di esecuzione ed ecosistemi differenti.
Il confronto Java vs JavaScript diventa utile solo quando si guardano differenze concrete come tipizzazione, runtime, modello degli oggetti e contesti di utilizzo.
La nostra guida a JavaScript approfondisce il secondo linguaggio; qui interessa capire soprattutto dove finisce la somiglianza del nome.
| Aspetto | Java | JavaScript |
|---|---|---|
| Tipizzazione | statica e forte | dinamica |
| Modello principale | class-based | prototype-based, pur con sintassi class |
| Ambiente tipico | JVM e relativi runtime | motori JavaScript nel browser e runtime come Node.js |
| Web frontend | non è il normale linguaggio eseguito nelle pagine web moderne | è uno dei linguaggi fondamentali del browser |
| Backend | molto diffuso, soprattutto in sistemi enterprise | possibile attraverso runtime server come Node.js |
| Relazione fra i due | linguaggio autonomo | linguaggio autonomo, non una variante di Java |
Tipizzazione, modello del linguaggio ed esecuzione
In Java il compilatore può controllare staticamente numerose incompatibilità di tipo prima dell’esecuzione.
In JavaScript le variabili non sono vincolate allo stesso modello statico e i tipi sono associati ai valori durante l’esecuzione.
Anche il modello degli oggetti è differente. Java è principalmente basato su classi. JavaScript utilizza un sistema a prototipi, anche se la sintassi moderna permette di dichiarare class e può quindi apparire superficialmente più vicina a Java di quanto sia realmente.
Queste differenze incidono sul modo in cui progetti il software, sul tooling, sugli errori che puoi intercettare prima dell’esecuzione e sugli idiomi dei due ecosistemi.
JVM, browser e runtime: dove gira il codice
Java viene normalmente compilato verso bytecode destinato alla piattaforma JVM.
JavaScript nasce invece come linguaggio del browser e oggi può essere eseguito anche fuori dal browser tramite runtime dedicati.
Per questo anche il confronto “Java è compilato, JavaScript è interpretato” è troppo semplicistico. I runtime moderni utilizzano strategie di ottimizzazione e compilazione molto più articolate.
La distinzione utile per un principiante è un’altra:
Java → sorgente → bytecode → ambiente JVM JavaScript → sorgente → motore/runtime JavaScript
Da qui derivano ecosistemi e use case differenti.
Quando si usa Java e quando JavaScript
Se devi costruire l’interattività di una pagina web eseguita direttamente nel browser, JavaScript appartiene naturalmente a quel problema.
Se stai costruendo un backend enterprise, un servizio sulla JVM o un’applicazione che beneficia dell’ecosistema Java, Java può essere una scelta molto più naturale.
Nel backend esiste anche un’area di sovrapposizione: JavaScript può essere utilizzato lato server attraverso Node.js, mentre Java dispone di un ecosistema server consolidato.
Non serve quindi chiedersi quale dei due linguaggi sia “migliore” in assoluto. La domanda utile è quale runtime, ecosistema, modello di sviluppo e insieme di vincoli corrispondono al software che devi costruire.
Come iniziare a programmare in Java
Per iniziare non serve installare dieci framework.
Serve un JDK funzionante, un editor e la capacità di seguire il percorso completo dal file sorgente all’esecuzione. Gli IDE diventano molto utili rapidamente, ma è meglio capire almeno una volta cosa fanno al posto tuo.
Quale JDK scegliere per iniziare
Nel settembre 2026 le due scelte più evidenti sono JDK 27 e JDK 25 LTS.
Per un esercizio personale puoi tranquillamente studiare con la release corrente. Per un percorso che vuoi mantenere stabile o allineare a corsi, framework e infrastrutture, JDK 25 LTS può ridurre la probabilità di dover cambiare versione nel breve periodo.
Prima di installare qualcosa controlla comunque:
java -version javac -version
Potresti avere già una versione Java configurata, magari installata per un altro software.
Se stai seguendo una guida o lavorando a un progetto esistente, usa innanzitutto la versione richiesta dal progetto. Installare la release più nuova e poi forzare un’applicazione pensata per un’altra versione raramente è il modo migliore per imparare.
Il primo programma Java: scrittura, compilazione ed esecuzione
Il programma visto in precedenza è già sufficiente:
public class HelloJava {
public static void main(String[] args) {
System.out.println("Ciao, Java!");
}
}
Salvalo come:
HelloJava.java
Compilalo:
javac HelloJava.java
Poi eseguilo:
java HelloJava
Se tutto è configurato correttamente vedrai:
Ciao, Java!
Quello che conta non è il messaggio stampato. È aver visto l’intera catena:
sorgente → compilatore → class file → JVM → output
Quando utilizzerai un IDE, molti di questi passaggi avverranno dietro un pulsante Run. Sapere cosa c’è sotto rende molto più semplice diagnosticare errori relativi a versione del JDK, classpath, build e ambiente.
Cosa studiare dopo le basi: OOP, API, librerie e framework
Dopo il primo programma eviterei di passare immediatamente a un grande framework enterprise.
Prima consoliderei sintassi, tipi, condizioni, cicli, metodi e strutture dati. Poi classi, interfacce, composizione, ereditarietà, eccezioni, collections, generics, I/O e concorrenza di base.
Successivamente diventano importanti testing, dependency management e build tool. A quel punto framework e librerie iniziano a risolvere problemi che riconosci davvero, invece di apparire come sequenze di annotazioni e configurazioni da copiare.
Se il tuo obiettivo è lo sviluppo web, il percorso del web developer aiuta anche a collocare Java dentro uno stack più ampio: HTTP, database, frontend, API, deploy e testing contano quanto la sintassi del singolo linguaggio.
Un buon criterio è costruire presto un piccolo progetto completo. Per esempio un’API con alcune operazioni CRUD, validazione, persistenza e test insegna più sul lavoro reale di una lunga successione di esercizi che non comunicano fra loro.
Vantaggi e limiti del linguaggio Java
Java è sopravvissuto a molte generazioni tecnologiche perché risolve bene una classe ampia di problemi. Questo non significa che sia la scelta giusta per qualsiasi software.
I vantaggi diventano interessanti quando corrispondono alle necessità del progetto; gli stessi meccanismi possono diventare costi quando quelle necessità non esistono.
Portabilità, maturità ed ecosistema
Il vantaggio più noto è la separazione fra bytecode e sistema sottostante.
Se disponi di una JVM compatibile, una grande quantità di codice può essere eseguita senza ricompilarla specificamente per ogni sistema operativo. È un modello che ha favorito distribuzione e interoperabilità.
A questo si aggiungono decenni di ecosistema: librerie, framework, IDE, profiler, strumenti di test, build tool, monitoraggio, documentazione e competenze disponibili nel mercato.
La tipizzazione statica e il tooling possono diventare particolarmente utili quando un progetto cresce e deve essere mantenuto da molte persone per anni.
Anche la retrocompatibilità ha un valore concreto. Non significa che ogni programma Java scritto vent’anni fa possa essere spostato senza lavoro sull’ultima release, ma l’ecosistema dedica molta attenzione all’evoluzione delle applicazioni esistenti.
Verbosità, runtime e complessità: quando Java può avere meno senso
La struttura esplicita di Java può essere un vantaggio in grandi sistemi e risultare più pesante in programmi piccoli.
Per alcuni task esistono linguaggi con sintassi più concisa o un ciclo di sviluppo iniziale più leggero. Anche JVM, build tool, dipendenze e framework possono introdurre una quantità di infrastruttura sproporzionata se devi realizzare uno script di poche righe.
Il runtime ha inoltre un proprio costo in memoria, startup e warm-up. Le JVM moderne hanno strumenti e ottimizzazioni molto sofisticati, ma “gestito automaticamente” non significa “gratuito”.
Java ha meno senso anche quando l’ambiente target richiede nativamente un altro stack. Nel normale frontend del browser, per esempio, non sostituisce JavaScript. Nei nuovi progetti Android, Kotlin è generalmente il punto di partenza più naturale.
La decisione quindi non dovrebbe essere:
Java è vecchio o moderno?
Dovrebbe essere:
Il modello JVM, il tooling, l’ecosistema e le caratteristiche del linguaggio risolvono bene i vincoli del progetto che devo costruire?
È una domanda molto più utile anche quando la risposta finale è scegliere un’altra tecnologia.
Conclusione
Java oggi è molto diverso dall’immagine che può essere rimasta a chi lo associa ai plugin del browser.
Il cuore del modello è ancora riconoscibile: scrivi codice Java, lo compili in bytecode e lo esegui attraverso un ambiente compatibile con la JVM. Intorno a questo meccanismo si è costruito un ecosistema maturo che continua ad avere un ruolo importante soprattutto nel backend, nei sistemi enterprise e nelle applicazioni che devono essere mantenute nel tempo.
Capire bene il linguaggio Java significa soprattutto distinguere codice sorgente, bytecode, JVM e JDK, invece di trattare tutti questi componenti come se fossero la stessa cosa.
Per iniziare a studiarlo non serve memorizzare subito ogni framework. È più utile capire bene la relazione fra linguaggio, JDK, bytecode e Java Virtual Machine, compilare un piccolo programma e poi aumentare gradualmente la complessità.
E serve tenere separate le informazioni attuali da quelle storiche: Java 27 è la release corrente nel settembre 2026, JDK 25 è l’attuale LTS e applet, plugin browser e Java Web Start non descrivono più il modo normale in cui Java viene utilizzato.
Una volta chiari questi confini, diventa anche più facile decidere il passo successivo: approfondire la programmazione Java, entrare nello sviluppo backend, lavorare su una codebase Android oppure scegliere un ecosistema differente perché più adatto al problema.