Come installare JDK 15 (su Windows, macOS & Ubuntu) e iniziare la programmazione Java

Il Java Development Kit (JDK), ufficialmente chiamato “Java Platform Standard Edition” o “Java SE”, è necessario per scrivere ed eseguire programmi Java.

Al momento, l’OpenJDK sviluppato da Oracle e dalla comunità Java (@ https://openjdk.java.net/) fornisce un’implementazione di riferimento ufficiale del JDK libera e open-source.

Questo articolo è basato sul JDK Oracle (@ https://www.oracle.com/java/) (a causa dell’eredità), che è libero per uso personale e di sviluppo ma non più libero per uso commerciale.

Versioni JDK

Riferimento: “Storia delle versioni di Java” @ https://en.wikipedia.org/wiki/Java_version_history.

  1. JDK Alpha e Beta (1995): Sun Microsystem ha annunciato Java il 23 settembre 1995.
  2. JDK 1.0 (gennaio 1996): Originariamente chiamato Oak (dal nome della quercia fuori dall’ufficio di James Gosling). Rinominato in Java 1 in JDK 1.0.2.
  3. JDK 1.1 (febbraio 1997): Introdotto il modello di eventi AWT, le classi interne, JavaBean, JDBC e RMI.
  4. J2SE 1.2 (JDK 1.2) (dicembre 1998): Re-branded come “Java 2” e rinominato JDK in J2SE (Java 2 Standard Edition). Rilasciato anche J2EE (Java 2 Enterprise Edition) e J2ME (Java 2 Micro Edition). Includeva JFC (Java Foundation Classes – Swing, Accessibility API, Java 2D, Pluggable Look & Feel, e Drag & Drop). Introdotto anche il Collection Framework e il compilatore JIT.
  5. J2SE 1.3 (JDK 1.3) (maggio 2000): Introdotta la JVM Hotspot.
  6. J2SE 1.4 (JDK 1.4) (febbraio 2002): Introdotta la dichiarazione assert, l’IO non bloccante (nio), le API di logging, l’IO delle immagini, Java webstart, il supporto alle espressioni regolari (regex).
  7. J2SE 5.0 (JDK 5) (Settembre 2004): Chiamato ufficialmente 5.0 invece di 1.5 (eliminando l’1.). Introdotti generici, autoboxing/unboxing, annotazione, enum, varargs, ciclo for-each, importazione statica. Vedere “JDK 5 New Features”.
  8. Java SE 6 (JDK 6) (dicembre 2006): Rinominato J2SE in Java SE (Java Platform Standard Edition). Nessuna nuova caratteristica del linguaggio. Vedere “JDK 6 Nuove caratteristiche”.
  9. Java SE 7 (JDK 7) (luglio 2011): Prima versione dopo che Oracle ha acquistato Sun Microsystem – anche chiamata OracleJDK. Introdotte le stringhe nell’istruzione switch, i letterali interi binari, permettendo i trattini bassi nei letterali numerici, inferenza di tipo migliorata per la creazione di istanze generiche (o operatore diamante <>), cattura di più tipi di eccezione e rilancio delle eccezioni con controllo di tipo migliorato. Vedere “JDK 7 New Features”.
  10. Java SE 8 LTS (JDK 8) (marzo 2014): Incluso il supporto per le espressioni Lambda, metodi predefiniti e statici nelle interfacce, raccolta migliorata e runtime JavaScript. Integrato anche il sottosistema grafico JavaFX. Vedere “JDK 8 New Features”.
  11. Java SE 9 (JDK 9) (21 settembre 2017): Introdotta la modularizzazione del JDK (module) sotto il progetto Jigsaw, la Java Shell (jshell), e altro. Vedere “JDK 9 New Features”.
  12. Java SE 10 (18.3) (JDK 10) (marzo 2018): Introdotto var per la variabile locale di inferenza del tipo (simile a JavaScript). Introdotto il versioning del rilascio basato sul tempo con due rilasci ogni anno, a marzo e settembre, indicato come YY.M. Rimosso lo strumento di generazione di intestazioni native javah. Vedere “JDK 10 New Features”.
  13. Java SE 11 LTS (18.9) (JDK 11) (settembre 2018): Esteso var a espressione lambda. Standardizzato il client HTTP in java.net.http. Supportare TLS 1.3. Pulire il JDK e il pacchetto di installazione (rimossi i moduli JavaFX, JavaEE, CORBA, deprecato il motore JavaScript Nashorn). OracleJDK non è più libero per uso commerciale, ma OpenJDK è ancora libero. Vedere “JDK 11 New Features”.
  14. Java SE 12 (19.3) (JDK 12) (marzo 2019): Switch Expression (anteprima). Vedere “JDK 12 New Features”.
  15. Java SE 13 (19.9) (JDK 13) (settembre 2019): Switch Expression (anteprima), Blocco di testo multilinea (anteprima). Vedere “JDK 13 New Features”.
  16. Java SE 14 (20.3) (JDK 14) (marzo 2020): Records (anteprima)
  17. Java SE 15 LTS (20.9) (JDK 15) (settembre 2020):

“JDK” o “JRE”?

JRE (Java Runtime), che include una Java Virtual Machine e le librerie di base, è necessario per eseguire programmi Java. JDK (Java Development Kit), che include JRE più gli strumenti di sviluppo (come il compilatore e il debugger), è necessario per scrivere ed eseguire programmi Java. In altre parole, JRE è un sottoinsieme di JDK. Dal momento che si suppone che tu scriva programmi Java invece di eseguire semplicemente programmi Java, dovresti installare JDK, che include JRE.

Come installare JDK su Windows

Passo 0: Disinstalla le vecchie versioni di JDK/JRE

Ti consiglio di installare solo l’ultima JDK. Anche se puoi installare più versioni di JDK/JRE contemporaneamente, è un po’ disordinato.

Se hai precedentemente installato una o più vecchie versioni di JDK/JRE, disinstalla TUTTE. Vai su “Pannello di controllo” ⇒ (opzionale) “Programmi” ⇒ “Programmi e funzionalità” ⇒ Disinstalla TUTTI i programmi che iniziano con “Java”, come “Java SE Development Kit …”, “Java SE Runtime …”, “Java X Update …”, ed ecc.

Passo 1: Scaricare JDK
  1. Visita il sito di download del JDK (o Java SE) @ https://www.oracle.com/java/technologies/javase-downloads.html.
  2. Sotto “Oracle JDK”, clicca “JDK Download”.
  3. Scarica il “Windows x64 Installer” (es, “jdk-15.0.{x}_windows-x64_bin.exe” – circa 159MB), dove {x} è un numero di aggiornamento che cambia velocemente.
Step 2: Installare JDK

Esegui il programma di installazione scaricato. Accetta le impostazioni predefinite e segui le istruzioni sullo schermo per completare l’installazione. Per impostazione predefinita, JDK è installato nella directory “C:\Program Files\Java\jdk-15.0.{x}“, dove {x} indica il numero di aggiornamento.

Lancia “Esplora file”. Navigate fino a "C:\Program Files\Java" per ispezionare le directory. Prendete nota della vostra directory installata JDK jdk-15.0.{x}, in particolare, il numero di aggiornamento {x} che vi servirà nel prossimo passo.

Mi riferirò alla directory installata di JDK come <JAVA_HOME>, in questo articolo (corrispondente alla variabile d’ambiente %JAVA_HOME% in Windows o $JAVA_HOME in Unix/macOS).

Step 3: (SKIP for JDK 15) Includere la directory “bin” del JDK nel PATH

Il prompt dei comandi di Windows (CMD) cerca nella directory corrente e nelle directory elencate nella variabile d’ambiente PATH i programmi eseguibili.

I programmi di JDK (come il compilatore Java "javac.exe” e Java runtime "java.exe“) risiedono nella sottodirectory “bin” della directory installata di JDK. Il “bin” di JDK deve essere aggiunto nel PATH.

Prima di JDK 15, è necessario aggiungere esplicitamente il “bin” di JDK nel PATH“. A partire da JDK 15, il processo di installazione aggiunge la directory “C:\Program Files\Common Files\Oracle\Java\javapath” al PATH. La directory “javapath” è un collegamento a “javapath_target_xxxxxx“, che contiene una copia dei seguenti programmi JDK:

  • java.exe: Java Runtime
  • javac.exe: Compilatore Java
  • javaw.exe: Java Runtime per Windows senza console
  • jshell.exe: Java Command-line Shell (da JDK 10) – un Read-Evaluate-Print Loop (REPL) che valuta le dichiarazioni, gli enunciati e le espressioni man mano che vengono inseriti e mostra immediatamente i risultati.

Link è usato in modo da poter mantenere più copie (versioni) di JDK.

Per modificare la variabile d’ambiente PATH in Windows 10:

  1. Lancia “Pannello di controllo” ⇒ (opzionale) “Sistema e sicurezza” ⇒ “Sistema” ⇒ Clicca su “Impostazioni di sistema avanzate” nel pannello di sinistra.
  2. Passa alla scheda “Avanzate” ⇒ Fai clic sul pulsante “Variabili d’ambiente”.
  3. Sotto “Variabili di sistema” (il pannello inferiore), scorri verso il basso per selezionare la variabile “Percorso” ⇒ Fai clic su “Modifica…”.
  4. Per Windows 10 più recente:
    Vedrai una TABELLA che elenca tutte le voci PATH esistenti (se non è così, vai al passo successivo). Fare clic su “Nuovo” ⇒ Fare clic su “Sfoglia” e navigare alla directory “bin” del tuo JDK, cioè, “c:\Program Files\Java\jdk-15.0.{x}\bin“, dove {x} è il numero di aggiornamento della vostra installazione ⇒ Selezionate “Move Up” per spostare questa voce al TOP.
  5. Per Windows 10 più vecchio (È ora di cambiare il vostro computer!):
    (ATTENZIONE: Leggete questo paragrafo 3 volte prima di fare questo passo! Non premere “Applica” o “OK” finché non sei sicuro al 101%. Non c’è nessun UNDO!!!)
    (Per essere sicuri, copiate il contenuto del “Valore della variabile” nel blocco note prima di cambiarlo!!!
    Nel campo “Valore della variabile”, APPENDETE “c:\Program Files\Java\jdk-15.0.{x}\bin” (dove {x} è il numero di aggiornamento della vostra installazione) davanti a tutte le directory esistenti, seguito da un punto e virgola (;) per separare la directory bin del JDK dal resto delle directory esistenti. NON CANCELLARE nessuna voce esistente; altrimenti, alcune applicazioni esistenti potrebbero non funzionare.
    Variable name : PATHVariable value : c:\Program Files\Java\jdk-15.0.{x}\bin;

È necessario riavviare CMD perché le nuove impostazioni di ambiente abbiano effetto.

Passo 4: Verificare l’installazione del JDK

Lancia un CMD tramite uno dei seguenti mezzi:

  1. Clicca il pulsante “Cerca” ⇒ Digita “cmd” ⇒ Scegli “Prompt dei comandi”, oppure
  2. Clicca con il tasto destro del mouse il pulsante “Start” ⇒ esegui… ⇒ inserisci “cmd”, oppure
  3. Clicca il pulsante “Start” ⇒ Sistema Windows ⇒ Prompt dei comandi

Indica i seguenti comandi per verificare l’installazione di JDK:

  1. (Salta per JDK 15) Lancia il comando “path” per elencare il contenuto della variabile d’ambiente PATH. Controllate che il vostro JDK “bin” sia elencato nella PATH
    pathPATH=c:\Program Files\Java\jdk-15.0.{x}\bin;other entries...
  2. Seguire i seguenti comandi per verificare che JDK/JRE siano correttamente installati e visualizzare la loro versione:
    // Display the JDK versionjavac -versionjavac 15.0.1// Display the JRE versionjava -versionjava version "15.0.1" 2020-10-20Java(TM) SE Runtime Environment (build 15.0.1+9-18)Java HotSpot(TM) 64-Bit Server VM (build 15.0.1+9, mixed mode, sharing)
Step 5: Scrivere un programma Java Hello-World
  1. Creare una directory per mantenere i tuoi lavori, ad es, “d:\myProject” o “c:\myProject“. NON salvare i tuoi lavori in “Desktop” o “Documenti” perché sono difficili da individuare. Il nome della directory non deve contenere caratteri vuoti o speciali. Usate un nome significativo ma breve perché è più facile da digitare.
  2. Lancia un editor di testo di programmazione (come TextPad, NotePad++, Sublime Text, Atom). Inizia con un nuovo file e inserisci il seguente codice sorgente. Salva il file come “Hello.java“, nella tua directory di lavoro (per esempio, d:\myProject
    /* * First Java program to say Hello */public class Hello { // Save as "Hello.java" under "d:\myProject" public static void main(String args) { System.out.println("Hello, world!"); }}
Step 6: Compilare ed eseguire il programma Java Hello-World

JavaBasics_GettingStarted.png

Per compilare il codice sorgente “Hello.java“:

  1. Avviare una Shell CMD (Cerca ⇒ inserire “cmd” ⇒ selezionare “Prompt dei comandi”).
  2. Impostare il drive corrente sul drive dove si è salvato il file sorgente “Hello.java“.
    Se usate l’unità “c”, saltate questo passo.
    Se invece usate l’unità “d“, inserite “d:” come segue:
    d:D:\xxx>
  3. Impostare la directory di lavoro corrente sulla directory in cui avete salvato il vostro file sorgente tramite il comando cd (Cambia directory). Per esempio, supponiamo che il vostro file sorgente sia salvato nella directory “myProject“.
    cd \myProjectD:\myProject>
  4. Eseguite un comando dir (List Directory) per confermare che il vostro file sorgente è presente nella directory corrente.
    dir......xx-xxx-xx xx:xx PM 277 Hello.java......
  5. Invoca il compilatore JDK “javac” per compilare il codice sorgente “Hello.java
    javac Hello.java// If error message appears, correct your source code and re-compile

    La compilazione ha successo se il prompt dei comandi ritorna. Altrimenti, verrebbero mostrati dei messaggi di errore. Correggi gli errori nel tuo file sorgente e ricompila di nuovo. Controlla “Errori comuni di installazione JDK”, se incontri problemi nella compilazione del tuo programma.

  6. L’output della compilazione è una classe Java chiamata “Hello.class“. Esegui di nuovo un comando dir (List Directory) per controllare l’output.
    dir......xx-xxx-xx xx:xx PM 416 Hello.classxx-xxx-xx xx:xx PM 277 Hello.java......

Per eseguire il programma, invocare il Java Runtime “java“:

java HelloHello, world!

Tutto ciò che può andare male andrà male: Leggete “Errori comuni nell’installazione di JDK”.

Step 7: (Solo per utenti avanzati) Codice sorgente di JDK

Il codice sorgente di JDK è fornito e conservato in “<JAVA_HOME>\lib\src.zip” (o “<JAVA_HOME>\src.zip” prima di JDK 9). Vi consiglio vivamente di esaminare alcuni dei file sorgente come “String.javaMath.java“, e “Integer.java“, sotto “java\lang“, per imparare come programmano gli esperti.

Come installare JDK su macOS

Passo 1: Controllare se JDK è stato preinstallato

Per controllare se JDK è stato installato, aprire un “Terminale” (Cerca “Terminale”; o Finder ⇒ Vai ⇒ Utilità ⇒ Terminale) ed eseguire questo comando:

javac -version
  • Se viene restituito un numero di versione JDK (es.g., JDK x.x.x), allora JDK è già stato installato. Se la versione di JDK è precedente alla 1.8, procedere al Passo 2 per installare l’ultimo JDK; altrimenti, procedere al “Passo 3: Scrivere un programma Java Hello-world”.
  • Se appare il messaggio “comando non trovato”, JDK NON è installato. Procedere al “Passo 2: Installare JDK”.
  • Se appare il messaggio “Per aprire javac, è necessario un runtime Java”, selezionare “Installa” e seguire le istruzioni per installare JDK. Poi, procedi al “Passo 3: Scrivi un programma Java Hello-world”.
Passo 2: Scarica JDK
  1. Vai al sito di download di JDK (o Java SE) @ https://www.oracle.com/java/technologies/javase-downloads.html.
  2. Sotto “Oracle JDK”, clicca “JDK Download”.
  3. Scaricare il “macOS DMG installer” (ad esempio, jdk-15.0.{x}_osx-x64_bin.dmg – circa 172MB, dove {x} è un numero di aggiornamento che cambia velocemente).
Passo 3: Installare JDK/JRE
  1. Fare doppio clic sul file Disk Image (DMG) scaricato. Segui le istruzioni sullo schermo per installare JDK/JRE.
  2. Espelli il file DMG.
  3. Per verificare la tua installazione, apri un “Terminale” ed esegui questi comandi.
    // Display the JDK versionjavac -versionjavac 15.0.{x} // Display the JRE versionjava -versionjava version "15.0.{x}"...... // Display the location of Java Compilerwhich javac/usr/bin/javac // Display the location of Java Runtimewhich java/usr/bin/java
Passo 3: Scrivere un programma Java Hello-World
  1. Creare una directory chiamata “myProject” sotto la vostra directory “home” (Lanciare “Finder” ⇒ “Vai” ⇒ “Home”; Selezionare “File” ⇒ “Nuova cartella” ⇒ “myProject“).
    In macOS/Unix, la directory “home” dell’utente corrente può essere referenziata come “~“. Quindi, questa nuova directory può essere referenziata come “~/myProject“.
  2. Utilizzare un editor di testo di programmazione (come Sublime Text o Atom) per inserire il seguente codice sorgente e salvare come “Hello.java“sotto la directory “~/myProject“.
    (Se si utilizza l’editor di testo predefinito di macOS “TextEdit” (NON consigliato), è necessario aprire un nuovo file ⇒ scegliere “Formato” ⇒ “Crea testo semplice” ⇒ Inserire il codice sorgente ⇒ Salvare come “Hello.java
    /* * My First Java program to say Hello */public class Hello { // Save as "Hello.java" under "~/myProject" public static void main(String args) { System.out.println("Hello, world from Mac!"); }}

Passo 4: Compilare ed eseguire il programma Java Hello-World

MacJavaCompile.png

  1. Per compilare il codice sorgente “Hello.java“, aprire un nuovo “Terminale” (“Go” ⇒ “Utilità” ⇒ “Terminale”) ed eseguire questi comandi (come illustrato):
    // Change Directory (cd) to where "Hello.java" residescd ~/myProject // Check if "Hello.java" exists using list (ls) commandlsHello.java ...... // Compile "Hello.java" using JDK compiler "javac"javac Hello.java// If error message appears, correct your source code and re-compile // Check for the compiled output "Hello.class"lsHello.class Hello.java ......
  2. Per eseguire Hello-world, invocare il Java Runtime “java” come segue:
    java HelloHello, world from Mac!

Come installare JDK su Ubuntu

Proveremo sia OpenJDK (gratuito e open-source) che Oracle JDK (gratuito per uso personale e sviluppo, ma non per la produzione).

Step 0: Controllare se JDK è già stato installato

Aprire un terminale ed eseguire questo comando:

$ javac -version

Se un numero di versione JDK (es, “javac x.x.x“) appare, JDK è già stato installato. Puoi saltare l’installazione e passare a Open2.

Passo 1a: Installare OpenJDK

Per rimuovere OpenJDK, dai il comando:

$ sudo apt-get purge openjdk-\*
Passo 1b: Installare Oracle JDK
  1. Per scaricare Oracle JDK (Java SE) visitare il sito @ https://www.oracle.com/java/technologies/javase-downloads.html ⇒ Sotto “Oracle JDK”, cliccare “JDK Download” ⇒ Selezionare il pacchetto “Linux x64 Compressed Archive” (es, “jdk-15.0.{x}-linux-x64_bin.tar.gz” – 179MB).Il tarball sarà scaricato nella directory “~/Downloads“, per default.
  2. Installeremo JDK sotto “/usr/local/java” (o la directory JDK di default di Ubuntu /usr/lib/jvm; o /opt/java). Per prima cosa, create una directory “java” sotto “/usr/local“. Aprite un terminale ed eseguite questi comandi:
    $ cd /usr/local$ sudo mkdir java

    Estrarre il pacchetto scaricato (Controllare il nome del file scaricato!)

    $ cd /usr/local/java$ sudo tar xzvf ~/Downloads/jdk-15.0.{x}-linux-x64_bin.tar.gz // x: extract, z: for unzipping gz, v: verbose, f: filename

    JDK deve essere estratto in una cartella “/usr/local/java/jdk-15.0.{x}“, dove {x} è il numero di aggiornamento.

  3. Informare Ubuntu di utilizzare questo JDK/JRE:
    // Setup the location of java, javac and jshell via the "alternatives" system$ sudo update-alternatives --install "/usr/bin/java" "java" "/usr/local/java/jdk-15.0.{x}/bin/java" 1 // --install symlink name path priority$ sudo update-alternatives --install "/usr/bin/javac" "javac" "/usr/local/java/jdk-15.0.{x}/bin/javac" 1$ sudo update-alternatives --install "/usr/bin/jshell" "java/usr/local/java/jdk-15.0.{x}/bin/jshell" 1 // Use this Oracle JDK/JRE as the default$ sudo update-alternatives --set java /usr/local/java/jdk-15.0.{x}/bin/java // --set name path$ sudo update-alternatives --set javac /usr/local/java/jdk-15.0.{x}/bin/javac$ sudo update-alternatives --set jshell /usr/local/java/jdk-15.0.{x}/bin/jshell

    I passi precedenti impostano i collegamenti simbolici javajavacjshell a /usr/bin (che è nel PATH), che collegano a /etc/alternatives e quindi alla directory bin della JDK.
    Il sistema delle “alternative” mira a risolvere la situazione in cui diversi programmi che svolgono la stessa funzione (ad es, diverse versioni di JDK). Imposta dei link simbolici attraverso /etc/alternatives per riferirsi ai programmi effettivi da utilizzare.

    $ ls -ld /usr/bin/java*lrwxrwxrwx 1 root root xx xxx xx xx:xx /usr/bin/java -> /etc/alternatives/java...... $ ls -ld /etc/alternatives/java*lrwxrwxrwx 1 root root xx xxx xx xx:xx /etc/alternatives/java -> /usr/local/java/jdk-15.0.{x}/bin/java......// As the resultjava -> /usr/bin/java (thru PATH) -> /etc/alternatives/java -> /usr/local/java/jdk-15.0.{x}/bin/java (actual program)

    In alternativa, è possibile includere direttamente il bin del JDK nel PATH.

  4. Per verificare l’installazione di JDK, esegui questi comandi:
    // Show the Java Compiler (javac) version$ javac -versionjavac 15.0.{x} // Show the Java Runtime (java) version$ java -versionjava version "15.0.{x}"...... // Show the location of javac and java$ which javac/usr/bin/javac$ which java/usr/bin/java
  5. (Non fare questo passo – è curato dalle “alternative” nel passo 3. Tenere qui per mostrare come impostare PATH.)
    Aggiungi la directory binaria di JDK (“bin“) al “PATH” modificando “/etc/profile
    $ cd /etc$ sudo nano profile

    Aggiungete queste righe alla fine del file “/etc/profile“, sostituite “{x}” con il numero attuale:

    export JAVA_HOME=/usr/local/java/jdk-15.0.{x}export PATH=$JAVA_HOME/bin:$PATH

    Rilanciate il file di configurazione da:

    // Refresh$ source /etc/profile // Check the new settings for JAVA_HOME and PATH$ echo $JAVA_HOME/usr/local/java/jdk-15.0.{x} $ echo $PATH/usr/local/java/jdk-15.0.{x}/bin:......

Step 2: Compilare ed eseguire un programma Java Hello-world
  1. File Explorer ⇒ Home ⇒ Creare una nuova cartella chiamata “myProject” per mantenere i nostri lavori.
  2. Aprire “Editor di testo” (gedit). Inserite il seguente codice sorgente e salvate come “Hello.java” sotto la directory “~/myProject” creata in precedenza.
    public class Hello { // To save as "Hello.java" under "~/myProject" public static void main(String args) { System.out.println("Hello, world from Ubuntu!"); }}
  3. Per compilare il programma Java Hello-world, lanciare un terminale ed eseguire questi comandi:
    // Change directory to where the source code resides$ cd ~/myProject // List the contents of current directory. Check for "Hello.java"$ ls...... Hello.java ...... // Compile "Hello.java" into "Hello.class"$ javac Hello.java // Check for "Hello.class"$ ls...... Hello.class ......
  4. Esegui il programma Hello-world Java:
    // Run "Hello.class"$ java HelloHello, world from Ubuntu!

Note: A partire da JDK 11, è possibile compilare ed eseguire il programma hello-world in un solo passaggio tramite:

// Compile and Run "Hello.java" in one step without creating the ".class"$ java Hello.javaHello, world from Ubuntu!

Editori di codice sorgente & IDE per la programmazione Java

Eclipse IDE

  1. È necessario prima installare Eclipse. Leggi “Come installare Eclipse”.e >
  2. javaan poi procedere a scrivere il tuo primo programma Java. Leggi “Scrivere il tuo primo programma Java con Eclipse”.
  3. Eclipse ti permette di fare il debug grafico del programma. Leggi “Debug del programma in Eclipse”.

NetBeans IDE

  1. Devi prima installare NetBeans. Leggi “Come installare NetBeans”.
  2. Puoi poi procedere a scrivere il tuo primo programma Java. Leggi “Scrivere il tuo primo programma Java con NetBeans”.
  3. NetBeans ti permette di fare il debug del programma graficamente. Leggi “Debug del programma in NetBeans”.

Visual Studio (VS) Code IDE

Clicca QUI, cerca “VS Code for Java Programming”

Sublime Text (per Windows, macOS, Linux)

Clicca QUI, cerca “Sublime Text per la programmazione Java”

Atom (per Windows, macOS, Linux)

TextPad (solo per Windows)

Clicca QUI, cerca “TextPad per la programmazione Java”.

NotePad++ (solo per Windows)

Clicca QUI, cerca “NotePad++ per la programmazione Java”.

(JDK 11 New Feature) Lanciare un singolo file sorgente

Da JDK 11, puoi “compilare ed eseguire” un programma a singolo file in un solo passo, senza compilazione esplicita.

  1. Scrivi un “Hello.java” (vedi sezione precedente).
  2. Cancellare “Hello.class“, se esiste.
  3. Puoi compilare/eseguire “Hello.java” in un solo comando come segue:
    // Change directory to the directory containing Hello.java// Compile and Run in ONE commandjava Hello.javaHello, world!

Note:

  • Questo è applicabile solo al singolo file sorgente.
  • Non c’è bisogno di usare javac per compilare il programma.
  • Compila in memoria (senza produrre un file .class), ed esegue.
  • Questa funzione è stata introdotta per i principianti per imparare Java, e per i professionisti per testare una funzione Java.
  • Il nome del file e il nome della classe non devono necessariamente essere gli stessi.

Come impostare la variabile d’ambiente JAVA_HOME

Molte applicazioni Java (come Tomcat) richiedono che la variabile d’ambiente JAVA_HOME sia impostata sulla directory installata del JDK.

Vedi “Come impostare JAVA_HOME per Windows” o “Come impostare JAVA_HOME per macOS/Linux”.

Errori comuni nell’installazione di JDK

SYMPTOM: Cannot compile Java program from the CMD shell (e.g., "javac Hello.java" does not work!)ERROR MESSAGE: 'javac' is not recognized as an internal or external command, operable program or batch file.PROBABLE CAUSES: The PATH environment variable, which maintains a list of search paths for executable programs (including "javac.exe"), does not include JDK's bin directory.POSSIBLE SOLUTIONS: 1) Start a CMD shell (click "Start" button ⇒ "run..." ⇒ enter "cmd") and issue a path command: prompt> path PATH=....... 2) Check if it includes your JDK's "bin" directory. For example, suppose that your JDK is installed in "c:\program files\java\jdk-15.0.1", then PATH should include "c:\program files\java\jdk-15.0.1\bin". Otherwise, include JDK's bin directory in the PATH environment variable. Read "Step 3 of How to install JDK".

SYMPTOM: Can compile but cannot run Java program from the CMD shell (e.g., "java Hello" does not work!)ERROR MESSAGE (Post JDK 1.7): Error: Could not find or load main class XxxERROR MESSAGE (Pre JDK 1.7): Exception in thread "main" java.lang.NoClassDefFoundError: XxxPROBABLE CAUSES: 1) The Java class (in this example, Hello.class) is NOT in the current directory. 2) The CLASSPATH environment variable is set, but does not include the current directory ".".POSSIBLE SOLUTIONS: 1) Issue a "dir" command to list the contents of the current directory. Check that it contains the Java class to be run (e.g., Hello.class). You need to compile the source program (".java") to get the class file (".class"). 2) If the Java class is present in the current directory, issue a "set classpath" command to check its settings: prompt> set classpath CLASSPATH=....... If you receive the message "Environment variable CLASSPATH not defined" and your program is correct, I can't help you here. Otherwise, if the CLASSPATH is defined, for beginner, I suggest that you remove the CLASSPATH environment variable. From "Control Panel" ⇒ System ⇒ (Vista only) Advanced system settings ⇒ Switch to "Advanced" tab ⇒ Environment Variables ⇒ System variables (and also User variables) ⇒ Select variable "CLASSPATH" ⇒ Delete (Delete from both the System variables and User variables) 3) (For Advanced Users Only) If CLASSPATH is not set, it is defaulted to the current directory. However, if CLASSPATH is set, the current directory is NOT implicitly included. You can include the current directory (denoted by a single dot ".") in front of the existing class-paths. Read "Java Applications and Environment Variable" for more discussion on CLASSPATH.

SYMPTOM: Can compile but cannot run the Hello-world program (e.g., "java Hello" does not work!)ERROR MESSAGE (Post JDK 1.7): Error: Main method not found in class Hello.POSSIBLE SOLUTIONS: Check whether there is a main() method in your program, and the signature of your main() as shown in the error message.

(Avanzato) File JAR esterni e librerie native

Note: Questa sezione è applicabile a JDK precedenti a JDK 9. JDK 9 introduce un nuovo livello chiamato “modulo” sopra il pacchetto, e “jmod” file per moduli Java. È necessario rivedere questa sezione per JDK 9.

Pacchetti esterni di API Java (come Servlet API, MySQL Connector/J, JOGL, JUnit) sono spesso distribuiti in file JAR (Java Archive – un pacchetto a file singolo di molte classi Java simile a ZIP o TAR), con eventualmente librerie native (“.lib” e “.dll” in Windows, o “.a” e “.so” in Linux/macOS).

File JAR esterni (“.jar”)

Se i file JAR esterni non sono inclusi correttamente:

  • Durante la compilazione, si riceverà un errore di compilazione “cannot find symbol” per le classi appartenenti ai pacchetti esterni.
  • Durante l’esecuzione, si riceverà un errore di runtime “Could not find or load main class xxx” o “NoClassDefFoundError“.

Per includere i file JAR esterni, è possibile:

  1. (Prima di JDK 9) Copiare tutti i file JAR dei pacchetti esterni nelle directory di estensione di Java (NON applicabile da JDK 9).
    • Per Windows, la directory di estensione JDK si trova in “<JAVA_HOME>\jre\lib\ext” (ad esempio, “c:\Program Files\Java\jdk1.8.0_xx\jre\lib\ext“).
    • Per macOS, le directory di estensione JDK sono “/Library/Java/Extensions” e “/System/Library/Java/Extensions“.
    • Per Ubuntu, le directory di estensione JDK sono “<JAVA_HOME>/jre/lib/ext” (ad esempio, “/usr/user/java/jdk1.8.0_xx/jre/lib/ext“) e “/usr/java/packages/lib/ext“.

    La posizione delle directory di estensione del JDK è tenuta nella proprietà di sistema di Java “java.ext.dirs“. È possibile stampare il suo contenuto tramite System.out.println(System.getProperty("java.ext.dirs")).

  2. È anche possibile includere tutti i file JAR nella variabile di ambiente CLASSPATHCLASSPATH può contenere directory (di classi Java) o file JAR (archivio a file singolo di classi Java). Se si imposta la variabile CLASSPATH, è necessario includere anche la directory corrente (indicata come “.“).
    • Per Windows, impostare il CLASSPATH in Pannello di controllo ⇒ Sistema ⇒ Impostazioni di sistema avanzate ⇒ Avanzate ⇒ Variabili di ambiente ⇒ Variabili di sistema ⇒ Nuovo ⇒ In “Nome della variabile”, inserire “CLASSPATH” ⇒ In “Valore della variabile”, inserire “.;path1\xxx.jar;path2\yyy.jar“, dove le voci sono separate da un punto e virgola (;).
    • Per Linux e macOS: modificare ~/.profile o ~/.bash_profile (o /etc/profile per l’impostazione a livello di sistema) per includere la seguente linea alla fine del file:
      export CLASSPATH=.:path1/xxx.jar:path2/yyy.jar

      Le voci sono separate da due punti (:).

  3. Si può anche impostare il CLASSPATH nella javacjava linea di comando-tramite l’opzione -cp <paths> (o -classpath <paths>), per esempio,
    // For Windows// Compile Java source codejavac -cp .;path1\xxx.jar;path2\yyy.jar ClassName.java// Run Java classjava -cp .;path1\xxx.jar;path2\yyy.jar ClassName // For macOS and Ubuntu// Compile Java source codejavac -cp .:path1/xxx.jar:path2/yyy.jar ClassName.java// Run Java classjava -cp .:path1/xxx.jar:path2/yyy.jar ClassName
Biblioteche native esterne (“.lib”, “.dll”, “.a”, “.so”)

Alcuni pacchetti esterni possono fornire librerie native statiche o condivise sotto forma di “.lib” (Libreria statica di Windows), “.dll” (Libreria a collegamento dinamico di Windows), “.a” (Libreria statica (Archivio) di Unix), o “.so” (libreria Shared Object di Unix).

Le librerie native devono essere tenute in una directory accessibile tramite la proprietà di JRE “java.library.path“, che normalmente ma non necessariamente include tutte le directory nella variabile d’ambiente PATH.

Le librerie native non sono coinvolte nella compilazione. Ma se non sono incluse correttamente durante il runtime, si otterrà un errore di runtime “java.lang.UnsatisfiedLinkError: no xxx in java.library.path“.

Per includere le librerie native esterne:

  1. Copiare le librerie native in una directory di libreria di sistema, ad es, c:\windows\system32 (Windows), /usr/lib o /usr/local/lib (macOS/Unix). Potete verificare che la directory sia inclusa nella proprietà di sistema di Java “java.library.path“, tramite System.out.println(System.getProperty("java.library.path")).
  2. È anche possibile impostare il percorso della libreria nativa tramite l’opzione della riga di comando java-Djava.library.path=xxx, per esempio,
    // Run a Java programjava -Djava.library.path=xxx ClassName
Eclipse/NetBeans

L’utilizzo di un IDE può semplificare notevolmente l’inclusione di pacchetti esterni. Leggere “Eclipse How-To” o “NetBeans How-To”.

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *