Variabili in Java: dichiarazione, assegnazione e scope

Cos'è una variabile

Una variabile è una scatola con un nome che contiene un valore. In Java ogni variabile ha un tipo fisso, deciso quando la dichiari, e quel tipo non cambia mai. È questo che rende Java tipizzato staticamente: il compilatore conosce il tipo di ogni variabile prima che il programma venga eseguito, e si rifiuta di compilare codice che mette il tipo di valore sbagliato in una scatola.

Una dichiarazione ha tre parti: il tipo, il nome e (di solito) un valore iniziale.

public class Main {
    public static void main(String[] args) {
        int age = 30;
        String name = "Ada";
        boolean isActive = true;

        System.out.println(name + " is " + age + ", active: " + isActive);
    }
}

Leggi int age = 30; come "crea un int chiamato age e mettici dentro 30". Il punto e virgola chiude l'istruzione, come hai visto nella pagina sui commenti che succede per ogni istruzione.

Dichiarare ora, assegnare dopo

Puoi separare una dichiarazione dalla sua prima assegnazione. Il tipo compare una sola volta, nella dichiarazione; dopo assegni usando solo il nome e =:

public class Main {
    public static void main(String[] args) {
        int score;        // dichiarata, ancora senza valore
        score = 95;       // assegnata ora
        score = 100;      // riassegnata: va benissimo

        System.out.println(score);
    }
}

Una regola che fa inciampare chi inizia: devi assegnare un valore a una variabile locale prima di leggerla. Il compilatore lo controlla e rifiuta il codice che legge una variabile locale non inizializzata:

int score;
System.out.println(score);   // compile error: variable score might not have been initialized

È una funzionalità, non un fastidio: intercetta un'intera categoria di bug prima ancora che il programma venga eseguito.

Regole e convenzioni sui nomi

Java impone alcune regole rigide, a cui si aggiungono delle convenzioni. Le regole: un nome può contenere lettere, cifre, _ e $, ma non può iniziare con una cifra, non può essere una parola chiave riservata (come int o class) e distingue maiuscole e minuscole (age e Age sono due variabili diverse).

Le convenzioni che seguono tutti:

• Variabili e metodi usano il camelCase: firstName, totalScore.
• Le costanti usano UPPER_SNAKE_CASE: MAX_USERS.
• I nomi devono descrivere il valore: count, non c; userEmail, non x.

public class Main {
    public static void main(String[] args) {
        int itemCount = 3;
        double pricePerItem = 4.50;
        double totalPrice = itemCount * pricePerItem;

        System.out.println("Total: " + totalPrice);
    }
}

I nomi chiari non sono decorazione: sono il modo in cui il te del futuro leggerà il codice. totalPrice = itemCount * pricePerItem si spiega da solo, cosa che t = c * p non farà mai.

Sicurezza dei tipi: la scatola mantiene il suo tipo

Poiché il tipo viene fissato nella dichiarazione, non puoi mettere in una variabile un valore del tipo sbagliato. Gli errori vengono intercettati in fase di compilazione:

int age = 30;
age = "thirty";   // compile error: incompatible types - String cannot become int

L'assegnazione tra tipi numerici segue le regole di allargamento: un tipo più piccolo passa automaticamente in uno più grande, ma non il contrario. Lo vedremo per intero nelle pagine sui tipi di dato e sul type casting; per ora ti basta sapere che il compilatore controlla.

La parola chiave var

Da Java 10 puoi scrivere var al posto del tipo e lasciare che il compilatore lo deduca dal valore a destra:

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        var name = "Ada";              // dedotto come String
        var count = 5;                 // dedotto come int
        var prices = new ArrayList<Double>();

        prices.add(9.99);
        System.out.println(name + " " + count + " " + prices);
    }
}

var non è tipizzazione dinamica: name è una String esattamente come se avessi scritto String name, e non puoi assegnarle un int più avanti. Ti fa solo scrivere meno. Il limite: var ha bisogno di un valore iniziale da cui dedurre il tipo, quindi var x; non è valido, e funziona solo per le variabili locali, mai per campi, parametri dei metodi o tipi di ritorno. Usalo quando il tipo è evidente dal lato destro; scrivi il tipo per esteso quando rende il codice più chiaro.

Costanti con final

Quando un valore non deve mai cambiare dopo essere stato impostato, segnalo come final. Qualsiasi tentativo di riassegnarlo diventa un errore di compilazione:

public class Main {
    public static void main(String[] args) {
        final double TAX_RATE = 0.20;
        double price = 50.0;

        System.out.println("Tax: " + price * TAX_RATE);

        // TAX_RATE = 0.25;   // non compilerebbe: non puoi riassegnare una variabile final
    }
}

final comunica un'intenzione ("questo è un valore fisso") e lascia che sia il compilatore a proteggerlo per te. Usalo ogni volta che un valore è concettualmente una costante (tassi, limiti, chiavi di configurazione), così una riassegnazione accidentale viene intercettata invece di diventare in silenzio un bug.

Scope delle variabili

Una variabile esiste solo dentro il blocco, cioè le { ... }, in cui è dichiarata, e muore alla graffa di chiusura. È il suo scope (ambito di visibilità). Una variabile dichiarata dentro un ciclo for o un blocco if è invisibile al di fuori:

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

        for (int i = 1; i <= 3; i++) {
            int square = i * i;     // 'square' vive solo nel corpo di questo ciclo
            total += square;
        }

        System.out.println("Total: " + total);
        // System.out.println(square);   // errore: qui 'square' è fuori scope
    }
}

Sia i sia square appartengono al ciclo e spariscono quando finisce; total è dichiarata nel blocco esterno, quindi sopravvive. In pratica: dichiara ogni variabile nel blocco più piccolo che ne ha bisogno. Uno scope ristretto significa meno nomi che competono per la tua attenzione e meno occasioni di usare male un valore lontano da dove è stato impostato.

Prossima pagina: tipi di dato

Ogni variabile di questa pagina è partita da un tipo: int, double, String, boolean. La prossima pagina analizza nel dettaglio i tipi di dato di Java: gli otto tipi primitivi, quanto spazio occupa ciascuno, la differenza tra primitivi e oggetti e quale tipo usare in ogni situazione.