Tipi di dati in Java: primitivi, tipi riferimento e valori predefiniti

Due famiglie: primitivi e riferimenti

Ogni valore in Java ha un tipo, e quel tipo appartiene a una di due famiglie. I tipi primitivi contengono direttamente un valore grezzo: un numero, un singolo carattere o un vero/falso. I tipi riferimento contengono un riferimento (un puntatore) a un oggetto che si trova altrove in memoria: String, gli array e ogni classe definita da te o dalle librerie.

La distinzione conta perché i primitivi sono leggeri e vengono copiati per valore, mentre le variabili riferimento puntano a oggetti condivisi. Parti dagli otto primitivi: sono le fondamenta su cui è costruito tutto il resto.

Gli otto tipi primitivi

Java ha esattamente otto tipi primitivi predefiniti. Sei sono numeri, uno è un carattere e uno è un booleano:

public class Main {
    public static void main(String[] args) {
        byte   b = 100;          // intero a 8 bit,  -128 .. 127
        short  s = 30000;        // intero a 16 bit
        int    i = 2_000_000;    // intero a 32 bit (il default per i numeri interi)
        long   big = 9_000_000_000L; // intero a 64 bit: nota la L

        float  f = 3.14f;        // decimale a 32 bit: nota la f
        double d = 3.141592653589793; // decimale a 64 bit (il default per i decimali)

        char   c = 'A';          // un singolo carattere Unicode a 16 bit
        boolean flag = true;     // solo true o false

        System.out.println(b + " " + s + " " + i + " " + big);
        System.out.println(f + " " + d);
        System.out.println(c + " " + flag);
    }
}

Alcune cose da notare subito: i trattini bassi in 2_000_000 sono solo separatori visivi che il compilatore ignora, i suffissi L e f sono obbligatori (ne parliamo più avanti), e char usa gli apici singoli mentre una String userebbe le virgolette doppie.

Scegliere un tipo numerico

Non ti servono quasi mai byte o short: fanno risparmiare memoria solo in array enormi. Le vere scelte sono tra int/long per i numeri interi e float/double per i decimali.

La trappola è l'overflow. Un int ricomincia dal basso in silenzio quando supera il suo intervallo: nessun errore, solo un risultato sbagliato:

public class Main {
    public static void main(String[] args) {
        int maxInt = Integer.MAX_VALUE; // 2147483647
        System.out.println(maxInt);
        System.out.println(maxInt + 1); // diventa un numero negativo!

        long safe = (long) maxInt + 1;  // prima lo promuoviamo a long
        System.out.println(safe);
    }
}

maxInt + 1 va in overflow e diventa -2147483648 perché entrambi gli operandi sono int e anche il risultato resta un int. Convertire prima uno dei due lati in long fa eseguire il calcolo a 64 bit. Quando un valore può essere grande, soprattutto i millisecondi dal 1970, usa long.

I letterali e i loro suffissi

Un letterale numerico da solo ha un tipo predefinito, e questo trae spesso in inganno. 100 è un int; 3.14 è un double. Per scrivere un letterale long o float devi aggiungere un suffisso:

public class Main {
    public static void main(String[] args) {
        long population = 8_000_000_000L; // senza L è troppo grande per int -> errore
        float ratio = 0.5f;               // senza f il lato destro è un double -> errore
        double pi = 3.14;                 // va bene: i decimali sono double di default

        System.out.println(population);
        System.out.println(ratio + " " + pi);
    }
}

Togli la L da 8_000_000_000L e il codice non compila, perché il letterale supera l'intervallo di int prima ancora di arrivare alla variabile long. Togli la f da 0.5f e Java si lamenta che un double non può essere assegnato a un float senza un cast. Il suffisso non distingue tra maiuscole e minuscole, ma usa la L maiuscola: una l minuscola sembra identica alla cifra 1.

char è un numero travestito

Un char memorizza un'unità di codice Unicode a 16 bit, quindi funziona anche come piccolo intero senza segno. Puoi farci dei calcoli e convertirlo avanti e indietro con un cast:

public class Main {
    public static void main(String[] args) {
        char letter = 'A';
        int code = letter;          // 65: il valore Unicode di 'A'
        char next = (char) (letter + 1); // 'B'

        System.out.println(code);
        System.out.println(next);
    }
}

A volte è utile per spostare le lettere, ma non affidarti a questo per il testo: per quello c'è String. Nota che char usa gli apici singoli ('A'); le virgolette doppie ("A") creano una String di un solo carattere, che è un tipo completamente diverso.

Valori predefiniti (e la trappola delle variabili locali)

I campi e gli elementi degli array che non inizializzi ricevono un valore predefinito sensato. Ma questo vale solo per campi e posizioni degli array: le variabili locali non hanno alcun valore predefinito, e usarne una prima di assegnarle un valore è un errore di compilazione, non una sorpresa a runtime.

public class Main {
    static int counter;        // campo -> vale 0 di default
    static boolean ready;      // campo -> vale false di default
    static String name;        // campo -> vale null di default

    public static void main(String[] args) {
        System.out.println(counter); // 0
        System.out.println(ready);   // false
        System.out.println(name);    // null

        int[] nums = new int[3];     // gli elementi dell'array valgono 0 di default
        System.out.println(nums[0]); // 0
    }
}

Se invece scrivessi int x; System.out.println(x); dentro main, il compilatore lo rifiuterebbe con "variable x might not have been initialized". Questa severità è una caratteristica utile: ti impedisce di leggere dati casuali. I valori predefiniti da ricordare: i tipi numerici 0, boolean false, char '�' e ogni tipo riferimento null.

Prossimo passo: le stringhe

String è il tipo riferimento che userai di più: testo, valori concatenati, input dell'utente. Si comporta in modo diverso dai primitivi visti qui: è un oggetto, è immutabile e confrontare stringhe ha le sue insidie. Ne parla la prossima pagina.