KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

Effectief finale lokale variabelen vastleggen

Een lambda kan een lokale variabele zonder de modifier `final` vastleggen als die effectief finaal is. Een vaste referentie maakt het object waarnaar die verwijst niet onveranderlijk.

Versie: Java SE 21

Syntax

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 mag een lambda of een innerlijke klasse, zoals een lokale of anonieme klasse, een lokale variabele of parameter uit het omringende bereik alleen gebruiken als die final of effectief finaal is. Een lokale variabele moet bovendien aantoonbaar een waarde hebben gekregen vóór de body van de lambda of innerlijke klasse. De waarde wordt vastgelegd, niet een beschrijfbare geheugenplaats. De lambda kan die waarde gebruiken nadat de omringende methode is teruggekeerd.

Een lokale variabele die met een initializer maar zonder final is gedeclareerd, is effectief finaal als ze nergens links van een toekenningsoperator of als operand van ++ of -- voorkomt. Dit geldt ook voor toekenningen in de initializer: int x = (x = 1); is geldig, maar x is niet effectief finaal. Parameters gelden als geïnitialiseerde variabelen. Zelfs x = x of x += 0 schendt de regel, ook na het aanmaken van de lambda; vastleggen geeft dan een compilatiefout. Een lokale variabele zonder final en zonder initializer kan in alternatieve takken een waarde krijgen en effectief finaal blijven. Bij elke toekenning moet na de evaluatie van de rechteroperand zowel vaststaan dat er nog geen waarde is toegekend als niet vaststaan dat er wel een waarde is toegekend. De variabele mag ook nooit een operand van ++ of -- zijn. Vóór het vastleggen moet wel vaststaan dat er een waarde is toegekend.

Je kunt de index i van een gewone for-lus die i met i++ bijwerkt niet vastleggen. Gebruik final int id = i; binnen de lus voor een kopie per iteratie. Een uitgebreide for heeft voor elke iteratie een aparte variabele, die je kunt vastleggen als ze final of effectief finaal blijft.

Bij een referentietype leg je de referentie vast, niet een kopie van het object. ++acc[0] verandert een array-element zonder acc opnieuw toe te kennen. Instantievelden en gedeelde static-velden volgen hun eigen regels, niet die voor het vastleggen van lokale variabelen. final biedt geen threadveiligheid: coördineer toegang tot gedeelde veranderlijke toestand, bijvoorbeeld door alle toegang tot die toestand met hetzelfde slot te beschermen.

Voorbeelden

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

Resultaat

task 0: 1
task 1: 2

`prefix` is effectief finaal, terwijl `id` en `acc` expliciet `final` zijn. Nadat `makeTasks()` terugkeert, gebruikt elke taak haar eigen `id`, maar beide verhogen hetzelfde `acc[0]`. De taken worden op één thread op volgorde uitgevoerd.

Gerelateerde lessen

  • Java · Les 22 · Gevorderd · Versie: 2
  • Java · Les 34 · Gevorderd · Versie: 2
  • Java · Les 36 · Gevorderd · Versie: 2
  • Java · Les 8 · Gemiddeld · Versie: 2

Bronnen