KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

Declaratie van een lokale klasse in Java

Een lokale klasse is een benoemde, geneste klasse die bijvoorbeeld in een methodeblok wordt gedeclareerd. Het bereik van haar naam beperkt de levensduur van haar instanties niet.

Versie: Java SE 21

Syntax

{
    class LocalName {
        // Fields, constructors, and methods
    }
    LocalName instance = new LocalName();
}

Een lokale klassendeclaratie zoals class Counter { ... } definieert een benoemde, geneste klasse rechtstreeks in een blok, bijvoorbeeld in de body van een methode, constructor of initialisatieblok. Ze is geen lid van de omsluitende klasse. Anders dan een anonieme klasse heeft ze een eenvoudige naam en kun je er apart een instantie van maken met new Counter().

Het bereik van de naam omvat de hele declaratie en de rest van het direct omsluitende blok. In een groep statements in een switch-blok eindigt het bereik bij het einde van die groep. Vóór de declaratie of buiten dat bereik duidt de naam deze klasse niet aan. Een instantie kan langer bestaan dan het blok: je kunt haar teruggeven als IntSupplier en gebruiken nadat de methode is afgelopen.

Bij een lokale klassendeclaratie zijn public, protected, private, static, sealed en non-sealed niet toegestaan. De directe superklasse en directe superinterfaces mogen niet sealed zijn. Een gewone lokale klasse is ook in een static-methode een innerklasse; daar heeft ze geen omsluitende instantie. In Java SE 21 mag ze wel eigen static-leden declareren. Lokale enum- en record-klassen zijn impliciet static. Het zijn dus geen innerklassen en ze vangen geen lokale variabelen of parameters uit de omsluitende context.

Instantiecode van een gewone lokale klasse kan lokale variabelen en parameters die binnen bereik zijn alleen vangen als ze final of effectief final zijn. De compiler moet ook kunnen vaststellen dat elke gevangen lokale variabele vóór de klassebody een waarde heeft gekregen. De parameter step is effectief final omdat die nooit een nieuwe waarde krijgt. De referentie total kan niet opnieuw worden toegewezen, maar total[0] kan wel veranderen: final maakt de array niet onveranderlijk.

Voorbeelden

import java.util.function.IntSupplier;

public class LocalClassDemo {
    static IntSupplier makeCounter(int step) {
        final int[] total = {0};

        class Counter implements IntSupplier {
            @Override
            public int getAsInt() {
                total[0] += step;
                return total[0];
            }
        }

        return new Counter();
    }

    public static void main(String[] args) {
        IntSupplier counter = makeCounter(3);
        System.out.println(counter.getAsInt());
        System.out.println(counter.getAsInt());
    }
}

Resultaat

3
6

`Counter` vangt de parameter `step` en de referentie `total`. Nadat `makeCounter(3)` is teruggekeerd, tellen opeenvolgende aanroepen van `getAsInt()` telkens `3` bij hetzelfde array-element op. Het programma toont dus eerst `3` en daarna `6`.

Gerelateerde lessen

  • Java · Les 14 · Gevorderd · Versie: 2
  • Java · Les 26 · Gevorderd · Versie: 2
  • Java · Les 36 · Gevorderd · Versie: 2
  • Java · Les 7 · Gemiddeld · Versie: 2

Bronnen