Variabili Java

Una variabile è una posizione di memoria denominata con un tipo fisso. Una volta dichiarato, il tipo non può cambiare, ma il valore al suo interno di solito può farlo. Il tipo controlla quanta memoria usa la variabile, quali valori sono consentiti e quali operazioni il compilatore permette. Questo capitolo spiega come dichiarare le variabili, come inizializzarle, i quattro tipi che Java distingue e le regole relative a final, var e lo scope.

Dichiarare una variabile

La forma di base è un tipo seguito da un nome e un punto e virgola:

type name;

Ad esempio, int score; riserva uno slot di tipo int chiamato score. Il tipo è uno dei tipi predefiniti di Java (int, double, boolean, char, …) oppure qualsiasi classe o interfaccia — vedi Java Data Types per l'elenco completo.

Le dichiarazioni più semplici:

int score;
String name;
boolean ready;

Queste riservano lo spazio in memoria; non assegnano ancora un valore.

Inizializzazione

Per assegnare un valore si usa =:

int score = 0;
String name = "Ada";
boolean ready = true;

È anche possibile dichiarare e assegnare separatamente:

int score;
score = 0;

Oppure dichiarare più variabili dello stesso tipo insieme:

int x = 1, y = 2, z = 3;

(Una per riga è di solito più chiara.)

Le variabili locali devono essere assegnate prima dell'uso

Una variabile locale — dichiarata all'interno di un metodo — non ha un valore predefinito. Il compilatore rifiuta di consentirne la lettura finché non le è stato assegnato un valore:

public static void main(String[] args) {
    int x;
    // System.out.println(x); // compile error: variable x might not have been initialized
    x = 5;
    System.out.println(x);    // OK
}

Questa è una delle funzionalità di sicurezza più utili di Java — intercetta una categoria di bug che altri linguaggi lasciano passare.

I quattro tipi di variabili

Java distingue quattro categorie di variabili in base a dove vengono dichiarate:

1. Variabili locali — dichiarate all'interno di un metodo o blocco. Esistono solo finché il metodo è in esecuzione. Nessun valore predefinito. Devono essere inizializzate prima dell'uso.
2. Variabili di istanza (campi) — dichiarate all'interno di una classe ma fuori da qualsiasi metodo. Una copia per ogni oggetto. Il valore predefinito è 0 / 0.0 / false / null.
3. Variabili statiche (variabili di classe) — dichiarate con la parola chiave static. Una copia condivisa da ogni istanza della classe. Il valore predefinito è 0 / false / null.
4. Parametri — dichiarati nella firma di un metodo; ricevono il valore passato dal chiamante.

public class Counter {
    static int totalCounters;   // static (class) variable
    int count;                  // instance variable

    public void add(int delta) { // delta is a parameter
        int doubled = delta * 2; // doubled is a local variable
        count += doubled;
    }
}

Le variabili di istanza e statiche vengono approfondite nei capitoli sulla OOP; per ora la maggior parte delle variabili che scriverai sarà locale.

final — assegna una volta sola

Aggiungere final davanti a una dichiarazione rende la variabile un'associazione monouso. Dopo la prima assegnazione, non può cambiare:

final int MAX_RETRIES = 3;
// MAX_RETRIES = 4; // compile error: cannot assign a value to final variable

Usare final per le cose che non devono cambiare rende l'intenzione esplicita e permette al compilatore di intercettare riassegnazioni accidentali. Per convenzione, i campi final che contengono costanti fisse vengono nominati in UPPER_SNAKE_CASE (vedi Java Naming Conventions).

Nota che final congela il riferimento, non l'oggetto a cui punta. Un riferimento final non può essere riassegnato, ma l'oggetto a cui fa riferimento può comunque essere modificato:

final int[] nums = {1, 2, 3};
nums[0] = 99;        // OK — the array contents change
// nums = new int[5]; // compile error — the reference is final

var — lascia che il compilatore scelga il tipo

Da Java 10, è possibile scrivere var al posto di un tipo per le variabili locali quando il lato destro rende il tipo ovvio:

var name = "Ada";          // inferred as String
var score = 0;             // inferred as int
var values = new int[10];  // inferred as int[]

var non è tipizzazione dinamica — la variabile ha ancora un tipo fisso, il compilatore lo deduce semplicemente al posto tuo. Restrizioni:

• Solo per variabili locali.
• Il lato destro deve essere presente (var x; non è valido).
• Non è consentito per parametri, variabili di istanza o variabili statiche.

var è più utile quando il nome del tipo è lungo o ovvio dal contesto:

var orders = new HashMap<String, List<Order>>();

Usa le dichiarazioni di tipo ordinarie quando il tipo dedotto non è ovvio per chi legge il codice.

Scope

Una variabile è in scope — visibile — dalla sua dichiarazione fino alla fine del blocco che la contiene:

public static void main(String[] args) {
    int outer = 1;

    if (outer > 0) {
        int inner = 2;
        System.out.println(outer + inner);   // both visible
    }

    // System.out.println(inner);   // compile error: inner is out of scope
}

Non è possibile dichiarare due variabili locali con lo stesso nome in scope sovrapposti — ma un nome può essere riutilizzato in due blocchi separati e non sovrapposti:

for (int i = 0; i < 3; i++) { /* i lives here */ }
for (int i = 0; i < 5; i++) { /* a new, separate i */ }  // fine

Mantenere piccoli gli scope delle variabili è una buona pratica: dichiara ogni variabile il più vicino possibile al punto in cui viene usata per la prima volta.

Un esempio funzionante

Cosa c'è dopo

Java Naming Conventions illustra le regole standard che ogni codebase Java segue per i nomi di classi, metodi, variabili e costanti.

Esercitazione