KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

Inner classes en de syntaxis `outer.new Inner(...)`

Een niet-statische geneste klasse die lid is van een andere klasse is gekoppeld aan een specifiek buitenobject en kan de privévelden ervan lezen.

Versie: Java SE 21

Syntax

class Outer {
    class Inner {
        Inner(int value) { /* initialize this Inner object */ }
    }

    Inner create(int value) {
        return new Inner(value); // enclosing instance: this Outer
    }
}

// In a method or initializer where the type and constructor are accessible:
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner(42);

In Java is een inner class een geneste klasse die niet expliciet of impliciet static is. Niet-statische lokale klassen en anonieme klassen vallen hier ook onder. Als zo'n lokale of anonieme klasse in een statische context wordt gedeclareerd, hebben haar objecten geen direct omsluitende instantie. Een instantie van een niet-statische lidklasse zoals Team.Member wordt bij het aanmaken juist gekoppeld aan een specifiek omsluitend object.

In outer.new Inner(...) levert outer het omsluitende object en gaan de argumenten tussen haakjes naar de constructor van Inner. Outer.Inner duidt het type aan, niet het omsluitende object. In een instantiemethode van Outer kan new Inner(...) impliciet this als omsluitend object gebruiken. In een statische context leidt het weglaten van de kwalificatie tot een compilatiefout. Als de kwalificerende expressie null oplevert, ontstaat er tijdens de uitvoering een NullPointerException. Het type en de constructor moeten wel toegankelijk zijn.

In een instantiemethode van Member verwijst this naar het Member-object en Team.this naar het omsluitende Team-object. Team.this.name leest het privéveld van het team, ook al heeft Member een eigen veld name. Een statische geneste klasse heeft geen impliciet omsluitend object en heeft een expliciete referentie nodig om de instantievelden van zo'n object te lezen. In Java SE 21 kan een inner class static-leden en statische initialisatieblokken declareren zonder zelf statisch te worden.

TaskList maakt een instantie van de private final-klasse FilteringIterator en geeft die terug als Iterator<Integer>. Elke iterator heeft een eigen index en leest source van de omsluitende lijst. De iterator slaat niet-positieve waarden over. Als er geen elementen meer zijn, gooit next() een NoSuchElementException. Het bewaren van de iterator kan het omsluitende TaskList-object in leven houden.

Voorbeelden

import java.util.Iterator;
import java.util.NoSuchElementException;

public class Main {
    public static void main(String[] args) {
        Team red = new Team("Red");
        Team blue = new Team("Blue");
        Team.Member first = red.new Member("Ada");
        Team.Member second = blue.new Member("Ada");
        System.out.println(first.label());
        System.out.println(second.label());

        TaskList tasks = new TaskList(0, 4, -1, 7);
        Iterator<Integer> positives = tasks.positiveIterator();
        while (positives.hasNext()) {
            System.out.println(positives.next());
        }
    }
}

final class Team {
    private final String name;

    Team(String name) {
        this.name = name;
    }

    class Member {
        private final String name;

        Member(String name) {
            this.name = name;
        }

        String label() {
            return Team.this.name + ": " + this.name;
        }
    }
}

final class TaskList {
    private final int[] source;

    TaskList(int... values) {
        source = values.clone();
    }

    Iterator<Integer> positiveIterator() {
        return new FilteringIterator();
    }

    private final class FilteringIterator implements Iterator<Integer> {
        private int index;

        @Override
        public boolean hasNext() {
            while (index < source.length && source[index] <= 0) {
                index++;
            }
            return index < source.length;
        }

        @Override
        public Integer next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            return source[index++];
        }
    }
}

Resultaat

Red: Ada
Blue: Ada
4
7

De twee `Member`-objecten hebben dezelfde naam, maar tonen verschillende teamnamen. Daarna toont de iterator alleen `4` en `7`, in hun volgorde in `source`.

Gerelateerde lessen

  • Java · Les 7 · Gemiddeld · Versie: 2
  • Java · Les 24 · Gemiddeld · Versie: 2

Bronnen