Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / Java

Klasy i interfejsy zagnieżdżone w Javie

Rozróżnij statyczną klasę zagnieżdżoną od klasy wewnętrznej. Zobacz też, jak publiczne interfejsy udostępniają etapy budowania, a generyczna klasa zagnieżdżona przechowuje wpisy pamięci podręcznej LRU.

Wersja: Java SE 21

Składnia

class Outer {
    public interface Step { Result build(); }
    private static final class Builder implements Step {
        public Result build() { return new Result(); }
    }
    public static final class Result {}
    static class LRUCache<K,V> {}
    class Inner {}
}
// Where accessible: new Outer.Result() vs. outer.new Inner()

Statyczna klasa zagnieżdżona nie ma niejawnej instancji klasy otaczającej. Poza nią używa się nazwy Outer.Nested; dostępny konstruktor można wywołać przez new Outer.Nested(). Dostęp do składowych instancji na osobnym obiekcie klasy otaczającej wymaga jawnej referencji do tego obiektu. Jeśli jednak klasa zagnieżdżona dziedziczy po klasie otaczającej, jej metody instancyjne mogą korzystać z odziedziczonych składowych instancji przez własne niejawne this. Dla porównania niestatyczna klasa składowa (inner class) ma instancję otaczającą i można ją utworzyć przez outer.new Inner().

W deklaracji static final class modyfikator static oznacza brak instancji otaczającej, a final zabrania tworzenia podklas. Żaden z tych modyfikatorów nie zapewnia niemutowalności obiektów. W deklaracji private static final class Builder modyfikator private dodatkowo ukrywa typ implementacji przed kodem klienckim spoza klasy otaczającej.

Interfejsy zagnieżdżone są niejawnie static; interfejs składowy klasy nie jest jednak automatycznie public. W przykładzie publiczne Main.TitleStep i Main.BuildStep określają dostępne operacje. Typ zwracany przez builder() nie udostępnia build(); ta metoda staje się dostępna po wywołaniu title(...).

static class LRUCache<K,V> deklaruje własne parametry typu: K dla klucza i V dla wartości. Nie może korzystać z parametrów typu klasy otaczającej. W przykładzie ustawienie kolejności dostępu w LinkedHashMap pozwala usunąć najdawniej używany wpis za pomocą pollFirstEntry(), gdy liczba wpisów przekroczy limit. Ta metoda pochodzi z API Java SE 21; przykładowa pamięć podręczna nie jest bezpieczna wątkowo.

Przykłady

import java.util.LinkedHashMap;

public class Main {
    public interface TitleStep {
        BuildStep title(String title);
    }

    public interface BuildStep {
        Report build();
    }

    public static TitleStep builder() {
        return new Builder();
    }

    private static final class Builder implements TitleStep, BuildStep {
        private String title;

        @Override
        public BuildStep title(String title) {
            this.title = title;
            return this;
        }

        @Override
        public Report build() {
            return new Report(title);
        }
    }

    public static final class Report {
        private final String title;

        private Report(String title) {
            this.title = title;
        }

        public String title() {
            return title;
        }
    }

    static class LRUCache<K,V> {
        private final int limit;
        private final LinkedHashMap<K,V> entries = new LinkedHashMap<>(16, 0.75f, true);

        LRUCache(int limit) {
            if (limit < 1) {
                throw new IllegalArgumentException("limit must be positive");
            }
            this.limit = limit;
        }

        V get(K key) {
            return entries.get(key);
        }

        void put(K key, V value) {
            entries.put(key, value);
            if (entries.size() > limit) {
                entries.pollFirstEntry();
            }
        }
    }

    public static void main(String[] args) {
        Report report = Main.builder().title("Report").build();
        System.out.println(report.title());

        Main.LRUCache<String, Integer> cache = new Main.LRUCache<>(2);
        cache.put("a", 1);
        cache.put("b", 2);
        System.out.println(cache.get("a"));
        cache.put("c", 3);
        System.out.println(cache.get("b"));
    }
}

Wynik

Report
1
null

Program nie tworzy obiektu `Main`. Odczyt `a` zwraca `1` i aktualizuje kolejność dostępu, więc dodanie `c` usuwa `b`. Późniejszy odczyt `b` zwraca `null`.

Powiązane lekcje

  • Java · Lekcja 37 · Średniozaawansowany · Wersja: 2
  • Java · Lekcja 38 · Średniozaawansowany · Wersja: 2
  • Java · Lekcja 40 · Średniozaawansowany · Wersja: 2

Źródła