Membri statici in Java: campi e metodi static

Appartenere alla classe, non all'oggetto

La maggior parte dei campi e dei metodi che hai scritto finora appartiene agli oggetti: ogni volta che chiami new, ogni istanza riceve la propria copia dei campi, e i metodi lavorano sullo stato di quell'oggetto specifico. La parola chiave static ribalta tutto questo. Un membro static appartiene alla classe stessa: ne esiste una sola copia, condivisa da tutte le istanze, ed esiste anche se non crei mai un oggetto.

Questa sola distinzione spiega i campi statici, i metodi statici, le costanti e perfino perché main è sempre static.

Un campo static condiviso

Un campo non statico dà a ogni oggetto il proprio spazio. Un campo static dà alla classe un solo spazio condiviso da tutti. L'esempio classico è un contatore che tiene traccia di quanti oggetti sono stati creati:

class User {
    static int count = 0;     // un solo spazio condiviso da tutta la classe
    String name;              // uno per oggetto

    User(String name) {
        this.name = name;
        count++;              // incrementa il contatore condiviso a ogni creazione
    }
}

public class Main {
    public static void main(String[] args) {
        new User("Ada");
        new User("Linus");
        new User("Grace");

        System.out.println("users created: " + User.count);
    }
}

Nota che leggi il contatore come User.count, tramite il nome della classe, perché il valore non appartiene a nessun User in particolare. Ogni name, invece, vive dentro il proprio oggetto. Se modifichi count tramite un'istanza qualsiasi, tutte le istanze vedono il nuovo valore, perché ne esiste uno solo.

Metodi static

Anche un metodo static appartiene alla classe, quindi lo chiami sulla classe senza un oggetto:

class MathUtils {
    static int square(int x) {
        return x * x;
    }

    static int max(int a, int b) {
        return a > b ? a : b;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(MathUtils.square(7));
        System.out.println(MathUtils.max(3, 9));
    }
}

È esattamente lo schema usato nella libreria standard: Math.max, Integer.parseInt, Arrays.sort e List.of sono tutti static, cioè comportamenti di utilità che non hanno bisogno di un oggetto su cui lavorare. Usa un metodo static quando il lavoro dipende solo dai suoi argomenti, non dallo stato di un oggetto.

La grande trappola: static non vede l'istanza

Un metodo static viene eseguito senza alcun oggetto, quindi non c'è nessun this. Significa che non può toccare campi di istanza o chiamare direttamente metodi di istanza: non c'è un oggetto specifico da cui leggerli. È l'errore più comune in assoluto per chi inizia con static:

class Account {
    int balance = 100;          // campo di istanza

    static int show() {
        return balance;         // ERRORE DI COMPILAZIONE: il campo non statico 'balance'
    }                           // non può essere usato da un contesto statico
}

La soluzione è trasformare il metodo in un metodo di istanza (togli static, così ha un this) oppure passargli l'oggetto in modo esplicito:

class Account {
    int balance = 100;

    static int show(Account a) {     // riceve l'oggetto come parametro
        return a.balance;
    }
}

public class Main {
    public static void main(String[] args) {
        Account a = new Account();
        System.out.println(Account.show(a));
    }
}

La direzione opposta va bene: un metodo di istanza può leggere liberamente i campi static e chiamare i metodi static, perché i dati condivisi a livello di classe esistono sempre.

Costanti con static final

Combina static con final e ottieni una costante: un unico valore condiviso che non può mai cambiare. Per convenzione, le costanti si scrivono in UPPER_SNAKE_CASE:

class Circle {
    static final double PI = 3.14159265;

    double radius;

    Circle(double radius) { this.radius = radius; }

    double area() {
        return PI * radius * radius;   // metodo di istanza che usa una costante static
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.printf("%.2f%n", new Circle(2).area());
    }
}

static final è il modo idiomatico per esprimere "un valore fisso che appartiene al tipo", come Integer.MAX_VALUE o Math.PI nella libreria standard. Renderlo static significa non sprecare una copia per ogni oggetto; renderlo final significa che nessuno può riassegnarlo.

Blocchi di inizializzazione static

Un semplice campo static si può inizializzare sulla stessa riga. Quando la preparazione richiede una vera logica, come costruire una tabella di ricerca con una HashMap o leggere una configurazione, usa un blocco static. Viene eseguito una volta, quando la classe viene caricata per la prima volta, prima che esista qualsiasi oggetto:

import java.util.HashMap;
import java.util.Map;

class Roman {
    static final Map<Character, Integer> VALUES = new HashMap<>();

    static {                       // eseguito una volta, al caricamento della classe
        VALUES.put('I', 1);
        VALUES.put('V', 5);
        VALUES.put('X', 10);
        VALUES.put('L', 50);
    }

    static int valueOf(char c) {
        return VALUES.get(c);
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(Roman.valueOf('X') + Roman.valueOf('I'));
    }
}

Il blocco viene eseguito una sola volta, indipendentemente da quante volte usi la classe, e questo lo rende il posto giusto per una preparazione unica valida per tutta la classe.

Quando usare static

Una regola pratica veloce:

• Usa un campo static solo per dati davvero condivisi da tutte le istanze: un contatore, una cache, una costante. Se due oggetti potrebbero ragionevolmente contenere valori diversi, deve essere un campo di istanza.
• Usa un metodo static quando il risultato dipende solo dagli argomenti, non dallo stato di un oggetto (funzioni di utilità pure).
• Parti dai membri di istanza. Abusare di static trasforma silenziosamente il programma in un mucchio di stato globale, difficile da testare e da capire. static è l'eccezione, non il punto di partenza.

Prossima pagina: enum

Una costante static final va bene per un singolo valore fisso, ma quando hai un piccolo insieme fisso di valori collegati (direzioni, giorni della settimana, stati di un ordine) Java ha un tipo apposito, più sicuro ed espressivo di tante costanti sparse. È l'enum, ed è l'argomento della prossima pagina.