WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

Innere Klassen und `outer.new Inner(...)`

Eine innere Mitgliedsklasse ist an ein bestimmtes Objekt der umschließenden Klasse gebunden und kann dessen private Felder lesen.

Version: 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 ist eine innere Klasse eine geschachtelte Klasse, die weder ausdrücklich noch implizit static ist. Dazu zählen auch nichtstatische lokale Klassen und anonyme Klassen. Wird eine solche lokale oder anonyme Klasse in einem statischen Kontext deklariert, haben ihre Objekte keine unmittelbar umschließende Instanz. Ein Objekt einer inneren Mitgliedsklasse wie Team.Member wird dagegen bei der Erzeugung an ein bestimmtes umschließendes Objekt gebunden.

In outer.new Inner(...) liefert outer das umschließende Objekt; die Argumente in Klammern werden an den Konstruktor von Inner übergeben. Outer.Inner bezeichnet den Typ, nicht das umschließende Objekt. In einer Instanzmethode von Outer kann new Inner(...) implizit this verwenden. In einem statischen Kontext führt ein fehlender Qualifizierer zu einem Kompilierfehler; ergibt der Qualifizierer null, tritt zur Laufzeit eine NullPointerException auf. Typ und Konstruktor müssen weiterhin zugänglich sein.

In einer Instanzmethode von Member bezeichnet this das Member-Objekt und Team.this das zugehörige Team-Objekt. Team.this.name liest das private Feld des Teams, obwohl Member ein eigenes Feld name hat. Eine statische geschachtelte Klasse hat kein implizites umschließendes Objekt und benötigt daher eine explizite Referenz, um dessen Instanzfelder zu lesen. In Java SE 21 darf eine innere Klasse static-Member und statische Initialisierer deklarieren, ohne dadurch statisch zu werden.

TaskList erzeugt ein Objekt der privaten final-Klasse FilteringIterator und gibt es als Iterator<Integer> zurück. Jeder Iterator hat einen eigenen Index und liest source der umschließenden Liste. Er überspringt nichtpositive Werte. Ist er erschöpft, löst next() eine NoSuchElementException aus. Ein aufbewahrter Iterator kann das zugehörige TaskList-Objekt am Leben halten.

Beispiele

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++];
        }
    }
}

Ergebnis

Red: Ada
Blue: Ada
4
7

Die beiden `Member`-Objekte tragen denselben Namen, geben aber unterschiedliche Teamnamen aus. Der Iterator gibt anschließend nur `4` und `7` in der Reihenfolge aus `source` aus.

Zugehörige Lektionen

  • Java · Lektion 7 · Mittlere Stufe · Version: 2
  • Java · Lektion 24 · Mittlere Stufe · Version: 2

Quellen