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
- Java Language Specification, Java SE 21 — §8.1.3 Inner Classes and Enclosing Instances
- Java Language Specification, Java SE 21 — §8.1.1.2 sealed, non-sealed, and final Classes
- Java Language Specification, Java SE 21 — §8.5 Member Class and Interface Declarations
- Java Language Specification, Java SE 21 — §9.1.1.3 static Interfaces
- Java Language Specification, Java SE 21 — §9.5 Member Class and Interface Declarations
- LinkedHashMap (Java SE 21 & JDK 21)
- SequencedMap (Java SE 21 & JDK 21) — pollFirstEntry()