CKTIS / Java
Geschachtelte Klassen und Schnittstellen in Java
Unterscheide statische geschachtelte Klassen von inneren Klassen, stelle Builder-Schritte über öffentliche Schnittstellen bereit und parametrisiere einen geschachtelten LRU-Cache.
Version: Java SE 21
Syntax
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()Eine statische geschachtelte Klasse hat keine implizite umschließende Instanz. Von außen heißt der Typ Outer.Nested; ist sein Konstruktor zugänglich, lässt sich ein Objekt mit new Outer.Nested() erzeugen. Wer auf Instanzmember eines separaten Objekts der umschließenden Klasse zugreift, braucht eine explizite Referenz auf dieses Objekt. Erbt die geschachtelte Klasse von der umschließenden Klasse, können ihre Instanzmethoden über ihr eigenes implizites this auf geerbte Instanzmember zugreifen. Eine nichtstatische Memberklasse (innere Klasse) hat dagegen eine umschließende Instanz und lässt sich mit outer.new Inner() erzeugen.
Bei static final class bedeutet static, dass es keine umschließende Instanz gibt; final verhindert Unterklassen. Keiner der beiden Modifikatoren macht Objekte unveränderlich. Bei private static final class Builder verbirgt private zusätzlich den Implementierungstyp vor aufrufendem Code außerhalb der umschließenden Klasse.
Geschachtelte Schnittstellen sind implizit static. Eine in einer Klasse deklarierte Member-Schnittstelle ist aber nicht automatisch public. Im Beispiel legen die öffentlichen Schnittstellen Main.TitleStep und Main.BuildStep die verfügbaren Operationen fest. Der Rückgabetyp von builder() bietet build() nicht an; erst title(...) liefert einen Typ mit dieser Methode.
static class LRUCache<K,V> deklariert eigene Typparameter: K für Schlüssel und V für Werte. Auf Typparameter der umschließenden Klasse kann sie nicht zugreifen. Das Beispiel nutzt eine nach Zugriffen geordnete LinkedHashMap. Überschreitet die Anzahl der Einträge das Limit, entfernt pollFirstEntry() den Eintrag, auf den am längsten nicht zugegriffen wurde. Die Methode stammt aus der Java-SE-21-API; der Beispielcache ist nicht threadsicher.
Beispiele
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"));
}
}Ergebnis
Report 1 null
Das Programm erzeugt kein `Main`-Objekt. Das Lesen von `a` gibt `1` zurück und aktualisiert die Zugriffsreihenfolge. Beim Einfügen von `c` wird daher `b` entfernt. Der spätere Zugriff auf `b` gibt `null` zurück.
Zugehörige Lektionen
- Java · Lektion 37 · Mittlere Stufe · Version: 2
- Java · Lektion 38 · Mittlere Stufe · Version: 2
- Java · Lektion 40 · Mittlere Stufe · Version: 2
Quellen
- 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()