Sintassi Java: classi, metodi, istruzioni e parentesi graffe

Com'è fatto un programma Java

Nella pagina precedente hai fatto partire Java. Ora vediamo di cosa è fatto davvero il codice. Java è rigoroso ed esplicito: c'è una forma fissa che ogni programma deve seguire, e il compilatore controlla quella forma prima che venga eseguita anche una sola riga.

Ecco il programma Java completo più piccolo possibile. Eseguilo:

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

Sono tante parole per stampare una sola riga e, a differenza di Python o JavaScript, non puoi saltarne nessuna. Ogni pezzo è obbligatorio, quindi vale la pena capire cosa fa ciascuno. Lo smonteremo dall'esterno verso l'interno.

Tutto vive dentro una classe

In Java non esiste codice "sciolto" al livello più alto di un file. Tutto il codice vive dentro una classe, dichiarata con la parola chiave class e un nome:

public class Main {
    // everything goes in here
}

La { di apertura e la } di chiusura corrispondente delimitano il corpo della classe. Il nome Main lo scegli tu, con una regola importante: in un normale file .java, una classe public deve avere esattamente lo stesso nome del file. Una public class Main va in Main.java. Sbaglia una maiuscola e il compilatore si rifiuta di compilarla.

Scoprirai cosa sono davvero le classi nel capitolo dedicato. Per ora considera public class Main { ... } l'involucro obbligatorio attorno al tuo codice.

Il metodo main è la linea di partenza

Quando esegui un programma Java, il runtime cerca un metodo ben preciso da cui iniziare l'esecuzione:

public static void main(String[] args) {
    // your code starts here
}

Questa firma non è negoziabile. Ogni parola ha un compito:

• public: il runtime può raggiungerlo dall'esterno della classe.
• static: viene eseguito senza creare prima un oggetto della classe.
• void: non restituisce nulla quando termina.
• main: il nome esatto che il runtime cerca.
• String[] args: un array con gli eventuali argomenti da riga di comando passati al programma.

Se anche una sola parola è sbagliata (Static invece di static, String args invece di String[] args), il codice potrebbe comunque compilare, ma all'avvio fallisce con Error: Main method not found in class Main. Quel messaggio indica quasi sempre un errore di battitura in questa riga.

Le istruzioni terminano con un punto e virgola

Un'istruzione è un comando completo. In Java ogni istruzione termina con un punto e virgola ;. Il compilatore usa il punto e virgola per capire dove finisce un comando e dove inizia il successivo: gli a capo per lui non contano.

public class Main {
    public static void main(String[] args) {
        int score = 90;
        score = score + 5;
        System.out.println(score);
    }
}

Dato che gli a capo vengono ignorati, tutte e tre le istruzioni potrebbero stare su una sola riga e funzionerebbero lo stesso, anche se nessuno scrive Java così:

int score = 90; score = score + 5; System.out.println(score);

Dimentica un punto e virgola e il compilatore ti ferma prima che il programma venga eseguito:

int score = 90
System.out.println(score);

error: ';' expected
        int score = 90
                      ^

Un punto e virgola mancante è l'errore di compilazione più comune in cui ti imbatterai all'inizio. Quando il compilatore indica una riga, controlla anche la riga sopra: spesso è lì la vera dimenticanza.

Blocchi e parentesi graffe

Le parentesi graffe { } raggruppano le istruzioni in un blocco. Il corpo di una classe è un blocco, il corpo di un metodo è un blocco, e il corpo di un if o di un ciclo è un blocco. I blocchi possono essere annidati dentro altri blocchi:

public class Main {
    public static void main(String[] args) {
        int hour = 9;

        if (hour < 12) {
            System.out.println("Good morning");
            System.out.println("Time to code");
        }
    }
}

Nota la differenza rispetto alle istruzioni: una riga che apre un blocco termina con {, non con un punto e virgola, e non si mette il punto e virgola dopo la } di chiusura di un metodo, una classe, un if o un ciclo. Confondere le due cose è un classico errore dei primi tempi:

public static void main(String[] args) {
    System.out.println("hi");
}; // <- this semicolon is unnecessary (and after a class/method, wrong)

L'indentazione negli esempi serve solo alle persone. Java la ignora, ma un'indentazione coerente è il modo in cui tu e chiunque altro capite quale { corrisponde a quale }. Lascia che l'editor indenti automaticamente e le parentesi si allineeranno da sole.

Java distingue maiuscole e minuscole

Per Java maiuscole e minuscole sono cose completamente diverse. score, Score e SCORE sono tre nomi distinti. Lo stesso vale per le parole chiave e i nomi predefiniti:

public class Main {
    public static void main(String[] args) {
        String name = "Ada";
        System.out.println("Hello, " + name);
    }
}

Se scrivessi system.out.println (con la s minuscola) o String Name e poi provassi a usare name, il compilatore lo rifiuterebbe. Alcuni nomi che chi inizia scrive spesso con le maiuscole sbagliate:

• System: con la S maiuscola. system.out.println(...) non compila.
• String: con la S maiuscola. È una classe, a differenza dei tipi primitivi in minuscolo.
• void, int, public, static: tutti in minuscolo. Sono parole chiave.

La maggior parte degli errori "cannot find symbol" nasce da una svista sulle maiuscole. L'errore ti dice perfino quale simbolo non ha trovato: confronta le sue maiuscole con quello che hai scritto.

Mettere insieme i pezzi

Ecco un programma un po' più grande che usa tutto ciò che hai visto in questa pagina: una classe, il metodo main, diverse istruzioni, un blocco annidato e maiuscole coerenti:

public class Main {
    public static void main(String[] args) {
        String city = "Lisbon";
        int temperature = 24;

        System.out.println("City: " + city);
        System.out.println("Temp: " + temperature + "C");

        if (temperature > 20) {
            System.out.println("Warm enough for shorts");
        }
    }
}

Leggilo dall'alto in basso: la classe racchiude tutto, main è il punto in cui parte l'esecuzione, ogni istruzione termina con ;, il corpo dell'if è raggruppato nel suo blocco e ogni nome predefinito ha le maiuscole giuste. È lo scheletro di praticamente ogni programma Java che scriverai.

Prossimo argomento: i commenti

Ora sai leggere la struttura di un file Java. La prossima cosa da aggiungere sono le note per le persone: testo che il compilatore ignora del tutto. La pagina successiva parla dei commenti: la forma su una riga //, la forma a blocco /* */ e quando un commento si guadagna davvero il suo posto nel codice.