Come eseguire Java: compilare con javac ed eseguire con java

Prima compili, poi esegui

Ora che hai installato un JDK, eseguire Java è un ciclo in due passaggi. A differenza di un linguaggio di scripting, dove indichi un file a un interprete e parti, Java prima compila il tuo sorgente leggibile in bytecode, e poi un passaggio separato esegue quel bytecode sulla JVM.

Questi due passaggi corrispondono a due strumenti da riga di comando inclusi nel JDK:

• javac: il compilatore. Legge Main.java e scrive Main.class (bytecode).
• java: il launcher. Avvia la JVM ed esegue il bytecode di Main.class.

Puoi eseguire qui sulla pagina qualsiasi esempio autonomo: l'editor qui sotto fa entrambi i passaggi per te. Vale però la pena capire cosa succede sul tuo computer, perché è lì che vivono i progetti veri.

public class Main {
    public static void main(String[] args) {
        System.out.println("Compiled, then run.");
    }
}

I due comandi sul tuo computer

Supponi di avere questo codice salvato come Main.java:

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello from the terminal");
    }
}

Apri un terminale nella cartella che contiene il file ed esegui il compilatore:

javac Main.java

Se il codice compila senza errori, javac non stampa niente e crea un nuovo file, Main.class, accanto al sorgente. Quel file .class è il bytecode: non è testo leggibile e non è legato al tuo sistema operativo.

Ora avvialo con il comando java:

java Main

Hello from the terminal

Qui si trova l'errore più comune in assoluto per chi inizia: per avviare il programma usi java, non javac, e passi il nome della classe senza estensione. Si scrive java Main, mai java Main.class e mai java Main.java.

Il nome del file deve corrispondere alla classe pubblica

Java impone una regola che sorprende chi è alle prime armi: una classe public deve stare in un file con esattamente lo stesso nome, più .java. Una public class Main deve stare in Main.java. Se sbagli le maiuscole, javac si rifiuta di compilare.

// This is in a file called Greeting.java
public class Greeting {   // ERROR: class Greeting should be in Greeting.java... wait, it is
    public static void main(String[] args) {
        System.out.println("Hi");
    }
}

La discrepanza che frega davvero le persone è più sottile: chiamare il file greeting.java (minuscolo) mentre la classe è Greeting, oppure salvare Main.java ma scrivere public class Hello. Il compilatore segnala qualcosa del genere:

Main.java:1: error: class Hello is public, should be declared in a file named Hello.java

La soluzione è sempre la stessa: rendi identici il nome del file e il nome della classe pubblica, carattere per carattere.

La scorciatoia: eseguire direttamente un singolo file

Da JDK 11 puoi saltare il passaggio esplicito di compilazione per un singolo file sorgente. Il comando java lo compila in memoria e lo esegue in un colpo solo, senza scrivere nessun file .class su disco:

java Main.java

È perfetto per esperimenti veloci e piccoli script. Nota la differenza in ciò che passi:

• java Main: esegue un Main.class già compilato.
• java Main.java: compila ed esegue il file sorgente in un colpo solo.

La modalità a file singolo funziona solo quando l'intero programma sta in un file. Appena dividi il codice in più classi in più file, torni a compilare prima con javac. Per imparare le basi, la modalità a file singolo mantiene il ciclo breve.

Passare argomenti al programma

Ti ricordi String[] args in main? Sono gli argomenti da riga di comando. Tutto ciò che scrivi dopo il nome della classe nel comando java finisce in quell'array:

public class Main {
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("No arguments given.");
        } else {
            System.out.println("First argument: " + args[0]);
            System.out.println("Total arguments: " + args.length);
        }
    }
}

Sul tuo computer gli passeresti gli argomenti così:

java Main hello world

First argument: hello
Total arguments: 2

L'editor qui sopra non può ricevere argomenti da terminale, quindi esegue il ramo "nessun argomento", ma lo stesso codice gestisce entrambi i casi. È così che i programmi Java leggono l'input passato all'avvio, molto prima di arrivare ai file o all'input dell'utente.

Leggere i messaggi di errore del compilatore

Quando javac rifiuta il tuo codice, ti dice il file, la riga e cosa è andato storto. Imparare a leggere questi messaggi è metà del lavoro per sbloccarti. Ecco un classico, un punto e virgola mancante:

public class Main {
    public static void main(String[] args) {
        System.out.println("Oops")   // no semicolon
    }
}

Main.java:3: error: ';' expected
        System.out.println("Oops")
                                  ^
1 error

L'accento circonflesso (^) indica dove il compilatore si aspettava qualcosa. Main.java:3 è il file con il numero di riga. Resisti alla tentazione di tirare a indovinare: leggi la riga, correggi l'unica cosa che indica e ricompila. Gli errori di compilazione significano che non è stato ancora eseguito niente; gli errori a runtime (che hanno un aspetto diverso) significano che il programma è partito e poi è fallito.

Un programma di verifica

Eseguilo nell'editor, oppure salvalo come Main.java ed esegui javac Main.java e poi java Main sul tuo computer. Se vedi tutte e tre le righe, i tuoi strumenti funzionano dall'inizio alla fine:

public class Main {
    public static void main(String[] args) {
        System.out.println("1. Java is running");

        int sum = 2 + 2;
        System.out.println("2. Two plus two is " + sum);

        String[] languages = {"Java", "Python", "JavaScript"};
        System.out.println("3. There are " + languages.length + " languages listed");
    }
}

Qui compaiono tre cose che vedrai per bene tra poco: una variabile int, la concatenazione di stringhe con + e un array con il suo .length. Per ora basta che il programma compili e stampi.

Prossima pagina: la sintassi di Java

Hai eseguito qualche programma, ma finora abbiamo sorvolato sulla punteggiatura: le graffe, i punti e virgola, public static void main e il motivo per cui ogni riga ha quell'aspetto. La prossima pagina scompone la sintassi di Java pezzo per pezzo, così la struttura smette di sembrare codice di rito e inizia ad avere senso.