Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Cattura di variabili locali effettivamente finali

Una lambda può catturare una variabile locale senza il modificatore `final` se è effettivamente finale. Un riferimento fisso non rende immutabile l’oggetto a cui punta.

Versione: Java SE 21

Sintassi

Java SE 21: a lambda expression or an inner class can use an enclosing local variable or parameter only if it is final or effectively final. A captured local variable must also be definitely assigned before the lambda or inner-class body. For example: String prefix = "task "; Runnable task = () -> System.out.println(prefix);

In Java SE 21, una lambda o una classe interna, per esempio una classe locale o anonima, può usare una variabile locale o un parametro dell’ambito esterno solo se è final o effettivamente finale. Una variabile locale deve anche essere definitivamente assegnata prima del corpo della lambda o della classe interna. Si cattura il valore, non una posizione scrivibile. La lambda può usare quel valore anche dopo che il metodo esterno è terminato.

Una variabile locale dichiarata con un inizializzatore ma senza final è effettivamente finale se non compare mai a sinistra di un operatore di assegnazione né come operando di ++ o --. Ciò vale anche per le assegnazioni nell’inizializzatore: int x = (x = 1); è valido, ma x non è effettivamente finale. I parametri sono trattati come variabili inizializzate. Anche x = x o x += 0 viola la regola, persino dopo la creazione della lambda; la cattura causa allora un errore di compilazione. Una variabile locale dichiarata senza final e senza inizializzatore può ricevere un valore in rami alternativi e rimanere effettivamente finale. Per ogni assegnazione, dopo la valutazione dell’operando destro, deve risultare sia sicuramente non assegnata sia non sicuramente assegnata. Inoltre, non deve mai essere un operando di ++ o --. Prima della cattura deve comunque risultare sicuramente assegnata.

Non puoi catturare l’indice i di un ciclo for di base che lo aggiorna con i++. Dichiara final int id = i; nel ciclo per ottenere una copia a ogni iterazione. Un for avanzato ha una variabile distinta per iterazione, catturabile se rimane final o effettivamente finale.

Per un tipo riferimento si cattura il riferimento, non una copia dell’oggetto. ++acc[0] modifica un elemento dell’array senza riassegnare acc. I campi di istanza e i campi static condivisi seguono regole proprie, non la regola di cattura delle variabili locali. final non garantisce la sicurezza tra thread: coordina l’accesso allo stato mutabile condiviso, per esempio proteggendo tutti gli accessi a quello stato con lo stesso lock.

Esempi

public class CaptureDemo {
    static Runnable[] makeTasks() {
        String prefix = "task ";
        final int[] acc = {0};
        Runnable[] tasks = new Runnable[2];

        for (int i = 0; i < tasks.length; i++) {
            final int id = i;
            tasks[i] = () -> System.out.println(prefix + id + ": " + ++acc[0]);
        }
        return tasks;
    }

    public static void main(String[] args) {
        Runnable[] tasks = makeTasks();
        tasks[0].run();
        tasks[1].run();
    }
}

Risultato

task 0: 1
task 1: 2

`prefix` è effettivamente finale, mentre `id` e `acc` sono dichiarati esplicitamente `final`. Dopo il ritorno di `makeTasks()`, ogni attività usa il proprio `id`, ma entrambe incrementano lo stesso `acc[0]`. Le attività vengono eseguite in ordine su un solo thread.

Lezioni correlate

  • Java · Lezione 22 · Avanzato · Versione: 2
  • Java · Lezione 34 · Avanzato · Versione: 2
  • Java · Lezione 36 · Avanzato · Versione: 2
  • Java · Lezione 8 · Intermedio · Versione: 2

Fonti