Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / Java

Klasa wewnętrzna i składnia `outer.new Inner(...)`

Klasa wewnętrzna będąca składową jest powiązana z konkretnym obiektem klasy otaczającej i może odczytywać jego prywatne pola.

Wersja: Java SE 21

Składnia

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

W Javie klasa wewnętrzna to klasa zagnieżdżona, która nie jest ani jawnie, ani niejawnie static. Należą do nich także niestatyczne klasy lokalne i klasy anonimowe. Gdy deklaracja takiej klasy lokalnej lub anonimowej znajduje się w kontekście statycznym, jej obiekty nie mają bezpośredniej instancji otaczającej. Natomiast każdy obiekt klasy wewnętrznej będącej składową, takiej jak Team.Member, jest przy tworzeniu wiązany z konkretną instancją otaczającą.

W outer.new Inner(...) wyrażenie outer wskazuje obiekt otaczający, a argumenty w nawiasach trafiają do konstruktora Inner. Outer.Inner to nazwa typu, nie obiekt otaczający. W metodzie instancji Outer można użyć new Inner(...): domyślną instancją otaczającą jest wtedy this. W kontekście statycznym brak takiego kwalifikatora powoduje błąd kompilacji, a kwalifikator o wartości null powoduje NullPointerException w czasie wykonania. Nadal obowiązują reguły dostępu do typu i konstruktora.

W metodzie instancji Member wyrażenie this oznacza obiekt Member, a Team.this oznacza powiązany z nim obiekt Team. Zapis Team.this.name odczytuje prywatne pole zespołu, mimo że Member ma własne pole name. Statyczna klasa zagnieżdżona nie ma domyślnego obiektu otaczającego: dostęp do jego pól instancji wymaga jawnej referencji. W Java SE 21 klasa wewnętrzna może deklarować składowe static i inicjalizatory statyczne; nie czyni jej to klasą statyczną.

TaskList deklaruje FilteringIterator jako prywatną klasę składową final. Metoda positiveIterator() tworzy instancję tej klasy i zwraca ją jako Iterator<Integer>. Każdy iterator ma własny indeks i odczytuje source powiązanej listy. Pomija liczby niedodatnie, a next() po wyczerpaniu elementów zgłasza NoSuchElementException. Przechowywanie takiego iteratora może przedłużyć życie powiązanego obiektu TaskList.

Przykłady

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

Wynik

Red: Ada
Blue: Ada
4
7

Dwa obiekty `Member` noszą to samo imię, ale wypisują różne nazwy zespołów. Iterator wypisuje potem tylko `4` i `7`, w kolejności z `source`.

Powiązane lekcje

  • Java · Lekcja 7 · Średniozaawansowany · Wersja: 2
  • Java · Lekcja 24 · Średniozaawansowany · Wersja: 2

Źródła