CKTIS / Java
Inner classes en de syntaxis `outer.new Inner(...)`
Een niet-statische geneste klasse die lid is van een andere klasse is gekoppeld aan een specifiek buitenobject en kan de privévelden ervan lezen.
Versie: 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 is een inner class een geneste klasse die niet expliciet of impliciet static is. Niet-statische lokale klassen en anonieme klassen vallen hier ook onder. Als zo'n lokale of anonieme klasse in een statische context wordt gedeclareerd, hebben haar objecten geen direct omsluitende instantie. Een instantie van een niet-statische lidklasse zoals Team.Member wordt bij het aanmaken juist gekoppeld aan een specifiek omsluitend object.
In outer.new Inner(...) levert outer het omsluitende object en gaan de argumenten tussen haakjes naar de constructor van Inner. Outer.Inner duidt het type aan, niet het omsluitende object. In een instantiemethode van Outer kan new Inner(...) impliciet this als omsluitend object gebruiken. In een statische context leidt het weglaten van de kwalificatie tot een compilatiefout. Als de kwalificerende expressie null oplevert, ontstaat er tijdens de uitvoering een NullPointerException. Het type en de constructor moeten wel toegankelijk zijn.
In een instantiemethode van Member verwijst this naar het Member-object en Team.this naar het omsluitende Team-object. Team.this.name leest het privéveld van het team, ook al heeft Member een eigen veld name. Een statische geneste klasse heeft geen impliciet omsluitend object en heeft een expliciete referentie nodig om de instantievelden van zo'n object te lezen. In Java SE 21 kan een inner class static-leden en statische initialisatieblokken declareren zonder zelf statisch te worden.
TaskList maakt een instantie van de private final-klasse FilteringIterator en geeft die terug als Iterator<Integer>. Elke iterator heeft een eigen index en leest source van de omsluitende lijst. De iterator slaat niet-positieve waarden over. Als er geen elementen meer zijn, gooit next() een NoSuchElementException. Het bewaren van de iterator kan het omsluitende TaskList-object in leven houden.
Voorbeelden
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++];
}
}
}Resultaat
Red: Ada Blue: Ada 4 7
De twee `Member`-objecten hebben dezelfde naam, maar tonen verschillende teamnamen. Daarna toont de iterator alleen `4` en `7`, in hun volgorde in `source`.
Gerelateerde lessen
- Java · Les 7 · Gemiddeld · Versie: 2
- Java · Les 24 · Gemiddeld · Versie: 2
Bronnen
- Java Language Specification, Java SE 21, §8.1.3 — Inner Classes and Enclosing Instances
- Java Language Specification, Java SE 21, §15.9 — Class Instance Creation Expressions
- Java Language Specification, Java SE 21, §15.8.4 — Qualified this
- Java Language Specification, Java SE 21, §6.6.1 — Determining Accessibility
- Iterator (Java SE 21 & JDK 21)