Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

Captura de variables locales efectivamente finales

Una lambda puede capturar una variable local sin el modificador `final` si es efectivamente final. Una referencia fija no vuelve inmutable al objeto referenciado.

Versión: Java SE 21

Sintaxis

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);

En Java SE 21, una lambda o una clase interna, como una clase local o anónima, puede usar una variable local o un parámetro del ámbito envolvente solo si es final o efectivamente final. Una variable local debe estar además definitivamente asignada antes del cuerpo de la lambda o de la clase interna. Se captura el valor, no una ubicación en la que se pueda escribir. La lambda puede usar ese valor después de que retorne el método envolvente.

Una variable local declarada con inicializador pero sin final es efectivamente final si nunca aparece a la izquierda de un operador de asignación ni como operando de ++ o --. Esto incluye las asignaciones dentro del inicializador: int x = (x = 1); es válido, pero x no es efectivamente final. Los parámetros se tratan como variables inicializadas. Incluso x = x o x += 0 rompe la regla, aunque aparezca después de crear la lambda; capturar esa variable produce un error de compilación. Una variable local declarada sin final ni inicializador puede recibir un valor en ramas alternativas y seguir siendo efectivamente final. En cada asignación, tras evaluar el operando derecho, debe estar definitivamente sin asignar y no debe estar definitivamente asignada. Tampoco puede ser operando de ++ ni de --. Antes de la captura, sí debe estar definitivamente asignada.

No se puede capturar el índice i de un bucle for básico que lo actualiza con i++. Declara final int id = i; dentro del bucle para obtener una copia por iteración. Un for mejorado tiene una variable distinta en cada iteración; se puede capturar si sigue siendo final o efectivamente final.

Si el tipo es de referencia, el valor capturado es la referencia, no una copia del objeto. ++acc[0] cambia un elemento del array sin reasignar acc. Los campos de instancia y los campos static compartidos se rigen por sus propias reglas, no por la de captura local. final no garantiza la seguridad entre hilos: coordina el acceso al estado mutable compartido, por ejemplo protegiendo todos los accesos a ese estado con el mismo bloqueo.

Ejemplos

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();
    }
}

Resultado

task 0: 1
task 1: 2

`prefix` es efectivamente final, mientras que `id` y `acc` se declaran explícitamente `final`. Tras el retorno de `makeTasks()`, cada tarea usa su propio `id`, pero ambas incrementan el mismo `acc[0]`. Las tareas se ejecutan en orden en un solo hilo.

Lecciones relacionadas

  • Java · Lección 22 · Avanzado · Versión: 2
  • Java · Lección 34 · Avanzado · Versión: 2
  • Java · Lección 36 · Avanzado · Versión: 2
  • Java · Lección 8 · Intermedio · Versión: 2

Fuentes