6.12 Innere Klassen
 
Bisher haben wir nur Klassen kennen gelernt, die entweder in Paketen organisiert waren oder in einer Datei. Diese Form von Klassen heißen »Top-Level-Klassen«. Es gibt darüber hinaus die Möglichkeit, eine Klasse in eine andere Klasse hineinzunehmen und sie damit noch enger aneinander zu binden. Eine Klasse, die so eingebunden wird, heißt »innere Klasse«. Im Allgemeinen sieht dies wie folgt aus:
class Außen {
class Innen {
}
}
Die Java-Sprache definiert vier Typen von inneren Klassen, die im Folgenden beschrieben werden.
6.12.1 Statische innere Klassen und Schnittstellen
 
Die einfachste Variante einer inneren Klasse oder Schnittstelle wird wie eine statische Eigenschaft in die Klasse eingesetzt und heißt statische innere Klasse. Wegen der Schachtelung wird dieser Typ im Englischen nested top-level class genannt. Die Namensgebung betont mit dem Begriff top-level, dass die Klassen das Gleiche können wie »normale« Klassen oder Schnittstellen. Insbesondere sind keine Exemplare der äußeren Klasse nötig. Sun betont in der Spachspezifikation, dass die statischen inneren Klassen keine »echten« inneren Klassen sind, doch soll uns das im Folgenden egal sein.
Beispiel Lampe ist die äußere Klasse, und Birne ist eine innere statische Klasse, die in Lampe geschachtelt ist.
|
Listing 6.68
Lampe.java
public class Lampe
{
static String s = "Huhu";
int i = 1;
static class Birne
{
void grüßGott()
{
System.out.println( s );
// System.out.println( i ); // Fehler, da i nicht statisch
}
}
}
Die Eigenschaften der statischen inneren Klasse Birne besitzen Zugriff auf alle anderen statischen Eigenschaften der äußeren Klasse Lampe. Ein Zugriff auf Objektvariablen ist aus der statischen inneren Klasse nicht möglich, da sie als extra Klasse gezählt wird, die im gleichen Paket liegt. Die innere Klasse muss einen anderen Namen als die äußere haben.
Umsetzung der inneren Klassen
Es ist eine gelungene Arbeit der Sun-Entwickler, die Einführung von inneren Klassen ohne Änderung der virtuellen Maschine über die Bühne gebracht zu haben. Der Compiler generiert aus den inneren Klassen nämlich einfach normale Klassen, die jedoch mit einigen Spezialfunktionen ausgestattet sind. Für die entschachtelten inneren Klassen generiert der Compiler neue Namen nach dem Muster: ÄußereKlasse$InnereKlasse, das heißt, ein Dollar-Zeichen trennt die Namen von äußerer und innerer Klasse.
6.12.2 Mitglieds- oder Elementklassen
 
Eine Mitgliedsklasse (engl. member class), auch Elementklasse genannt, ist ebenfalls vergleichbar mit einem Attribut, nur ist es nicht statisch. (Statische innere Klassen lassen sich aber auch als statische Mitgliedsklassen bezeichnen.) Die innere Klasse kann zusätzlich auf alle Attribute der äußeren Klasse zugreifen. Dazu zählen auch die privaten Eigenschaften, eine Designentscheidung, die sehr umstritten ist und kontrovers diskutiert wird.
Beispiel Rahmen besitzt eine innere Mitgliedsklasse Muster.
Listing 6.69
Rahmen.java
public class Rahmen
{
String s = "kringelich";
class Muster
{
void standard()
{
System.out.println( s );
}
// static void immer() { } // Fehler
}
}
|
Ein Exemplar der Klasse Muster hat Zugriff auf alle Eigenschaften von Rahmen. Um innerhalb der äußeren Klasse Rahmen ein Exemplar von Muster zu erzeugen, muss ein Exemplar der äußeren Klasse existieren. Das ist eine wichtige Unterscheidung gegenüber den statischen inneren Klassen von weiter oben. Statische innere Klassen existieren auch ohne Objekt der äußeren Klasse. Eine zweite wichtige Eigenschaft ist, dass innere Mitgliedsklassen selbst keine statischen Eigenschaften definieren dürfen.
Beispiel Für das Beispiel Rahmen und Muster erzeugt der Compiler die Dateien Rahmen.class und Rahmen$Muster.class. Damit ohne Änderung der virtuellen Maschine die innere Klasse an die Attribute der äußeren kommt, wird in jedem Exemplar der inneren Klasse eine Referenz auf das zugehörige Objekt der äußeren Klasse gelegt. Damit kann die innere Klasse auch auf nicht statische Attribute der äußeren zugreifen. Für die innere Klasse ergibt sich folgendes Bild in Rahmen$Muster.class:
class Rahmen$Muster
{
private Rahmen this$0;
// ...
}
|
Die Variable this$0 ist eine Kopie der Referenz auf Rahmen.this. Die Konstruktoren der inneren Klasse erhalten einen zusätzlichen Parameter vom Typ Rahmen, mit dem die this$0-Variable initialisiert wird.
Exemplare von inneren Klassen von außen erzeugen
Innerhalb der äußeren Klassen kann einfach mit dem new-Operator ein Exemplar der inneren Klasse erzeugt werden. Kommen wir von außerhalb und wollen Exemplare der inneren Klasse erzeugen, so müssen wir bei Elementklassen sicherstellen, dass es ein Exemplar der äußeren Klasse gibt. Die Sprache schreibt eine neue Form für die Erzeugung mit new vor, die das allgemeine Format
ref.new InnereKlasse(...)
besitzt. Dabei ist ref eine Referenz der äußeren Klasse.
Beispiel Die Klasse Haus besitzt die innere Element-Klasse Zimmer.
class Haus
{
class Zimmer
{
}
}
|
Um von außen ein Objekt von Zimmer aufzubauen, schreiben wir:
Haus h = new Haus();
Zimmer z = h.new Zimmer();
oder auch in einer Zeile
Zimmer z = new Haus().new Zimmer();
Die this-Referenz
Möchte eine innere Klasse In auf die this-Referenz der umgebenden Klasse Out zugreifen, schreiben wir Out.this. Wenn sich Variablen überdecken, so schreiben wir Out.this. Eigenschaft, um an die Eigenschaften der äußeren Klasse zu gelangen.
Beispiel Elementklassen können beliebig geschachtelt sein, und da der Name eindeutig ist, gelangen wir mit Klassenname.this immer an die jeweilige Eigenschaft.
|
Listing 6.70
Haus.java
class Haus
{
String s = "Haus";
class Zimmer
{
String s = "Zimmer";
class Stuhl
{
String s = "Stuhl";
void ausgabe()
{
System.out.println( s ); // Stuhl
System.out.println( this.s ); // Stuhl
System.out.println( Stuhl.this.s ); // Stuhl
System.out.println( Zimmer.this.s ); // Zimmer
System.out.println( Haus.this.s ); // Haus
}
}
}
public static void main( String[] args )
{
new Haus().new Zimmer().new Stuhl().ausgabe();
}
}
Betrachten wir das obere Beispiel, dann lassen sich Objekte für die inneren Klassen Haus, Zimmer und Stuhl wie folgt erstellen:
Haus a = new Haus; // Exemplar von Haus
Haus.Zimmer b = a.new Zimmer(); // Exemplar von Zimmer in a
Haus.Zimmer.Stuhl c = b.new Stuhl(); // Exemplar von Stuhl in b
c.ausgabe(); // Methode von Stuhl
Damit ist auch deutlich geworden, dass die Qualifizierung mit dem Punkt bei Haus.Zimmer.Stuhl nicht automatisch bedeutet, dass Haus ein Paket mit dem Unterpaket Zimmer ist, in dem die Klasse Stuhl existiert. Das macht es für die Lesbarkeit nicht gerade einfacher, und es droht eine Verwechslungsgefahr zwischen inneren Klassen und Paketen. Deshalb sollte die Namenskonvention befolgt werden: Klassennamen beginnen mit Großbuchstaben, Paketnamen mit Kleinbuchstaben.
6.12.3 Lokale Klassen
 
Lokale Klassen sind auch innere Klassen, die jedoch nicht als Eigenschaft direkt in einer Klasse eingesetzt werden. Diese Form der inneren Klasse befindet sich in Anweisungsblöcken von Methoden oder Initialisierungsblöcken. Lokale Schnittstellen sind nicht möglich.
Beispiel Die main()-Methode besitzt eine innere Klasse mit einem Konstruktor, der auf die finale Variable j zugreift.
|
Listing 6.71
DrinnenMachtSpass.java
public class DrinnenMachtSpass
{
public static void main( String[] args )
{
int i = 2;
final int j = 3;
class In
{
In() {
System.out.println( j );
// System.out.println( i ); // Fehler, da i nicht final
}
}
new In();
}
}
Die Definition der inneren Klasse In ist wie eine Anweisung eingesetzt. Jede lokale Klasse kann auf Methoden der äußeren Klasse zugreifen und zusätzlich auf die lokalen Variablen und Parameter, die mit dem Modifizierer final als unveränderlich ausgezeichnet sind. Liegt die innere Klasse in einer statischen Funktion, kann sie jedoch keine Objektmethode aufrufen. Eine weitere Einschränkung im Vergleich zu den Elementklassen ist, dass die Modifizierer public, protected, private und static nicht erlaubt sind.
6.12.4 Anonyme innere Klassen
 
Anonyme Klassen gehen noch einen Schritt weiter als lokale Klassen. Sie haben keinen Namen und erzeugen immer automatisch ein Objekt. Klassendefinition und Objekterzeugung sind zu einem Sprachkonstrukt verbunden. Die allgemeine Notation ist folgende:
new KlasseOderSchnitstelle() { /* Eigenschaften der inneren Klasse */ }
In dem Block geschweifter Klammern lassen sich nun Methoden und Attribute definieren. Hinter new steht der Name einer Klasse oder Schnittstelle.
|
Wenn hinter new der Klassenname A steht, dann ist die anonyme Klasse eine Unterklasse von A. |
|
Wenn hinter new der Name einer Schnittstelle S steht, dann erbt die anonyme Klasse von Object und implementiert die Schnittstelle S. Implementiert sie nicht die Operationen der Schnittstelle, haben wir nichts davon, denn dann hätten wir eine abstrakte innere Klasse, von der kein Objekt erzeugt werden könnte. |
Für anonyme innere Klassen gilt die Einschränkung, dass keine zusätzlichen extends- oder implements-Angaben möglich sind.
Beispiel Wir wollen eine innere Klasse schreiben, die Unterklasse von java.awt.Point ist. Sie soll die toString()-Methode überschreiben.
|
Listing 6.72
InnerToStringPoint.java
import java.awt.Point;
public class InnerToStringPoint
{
public static void main( String[] args )
{
Point p = new Point( 10, 12 ) {
@Override
public String toString() {
return "(" + x + "," + y + ")";
}
};
System.out.println( p ); // (10,12)
}
}
Da sofort eine Unterklasse von Point definiert wird, fehlt der Name der inneren Klasse. Das einzige Exemplar dieser anonymen Klasse lässt sich über die Variable p weiterverwenden.
Hinweis Eine innere Klasse kann Methoden der Oberklasse überschreiben oder Operationen aus Schnittstellen implementieren. Neue Eigenschaften anzubieten, wäre zwar legal, aber nicht sinnvoll, es sei denn, die innere Klasse selbst nutzt die Methoden – dann müssen sie aber unsichtbar sein. Von außen sind Methoden, die nicht in der Oberklasse beziehungsweise Schnittstelle bekannt sind, nicht sichtbar. Deshalb sind auch anonyme Unterklassen von Object (ohne weitere implementierte Schnittstellen) nutzlos.
|
Umsetzung innerer anonymer Klassen
Auch für innere anonyme Klassen erzeugt der Compiler eine normale Klassendatei. Wir haben gesehen, dass im Fall einer »normalen« inneren Klasse die Notation ÄußereKlasse$InnereKlasse gewählt wird. Das klappt bei anonymen inneren Klassen natürlich nicht mehr, da uns der Name der inneren Klasse fehlt. Der Compiler wählt daher folgende Notation für Klassennamen: InnerToStringDate$1. Falls es mehr als eine innere Klasse gibt, wird 1 zu 2, 2 zu 3 und so weiter.
Nutzung innerer Klassen für Threads
Sehen wir uns ein weiteres Beispiel für die Implementierung von Schnittstellen an. Um nebenläufige Programme zu implementieren, gibt es die Klasse Thread und die Schnittstelle Runnable. (Für das Beispiel greifen wir vor; Threads werden in Kapitel 9 genau beschrieben.)
Die Schnittstelle Runnable schreibt eine Operation run() vor, in der der parallel abzuarbeitende Programmcode gesetzt wird. Das geht gut mit einer inneren anonymen Klasse, die Runnable implementiert.
new Runnable() {
public void run() {
...
}
};
Das Exemplar kommt in den Konstruktor der Klasse Thread. Der Thread wird mit start() angekurbelt. Damit folgt zusammengesetzt und mit Implementierung von run():
new Thread( new Runnable() {
public void run() {
for ( int i = 0; i < 10; i++ )
System.out.println( i );
};
} ).start();
for ( int i = 0; i < 10; i++ )
System.out.println( i );
In der Ausgabe wird zum Beispiel Folgendes erscheinen (hier komprimiert):
0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 9 9
Der erste Thread beginnt recht schnell seine Zahlen auszugeben. Doch an der doppelten Zahl 9 sehen wir, dass die beiden Teile wirklich parallel arbeiten. Ausführliche Informationen finden sich im Thread-Kapitel.

(Strg)+[_____) nach der geschweiften Klammer listet eine Reihe von Methoden auf, die wir uns von Eclipse implementieren lassen können. Da entscheiden wir uns doch für run().
 Hier klicken, um das Bild zu Vergrößern
Konstruktoren innerer anonymer Klassen
Da anonyme Klassen keinen Namen haben, muss für Konstruktoren ein anderer Weg gefunden werden. Hier helfen Exemplarinitialisierungsblöcke, die Blöcke in geschweiften Klammen direkt innerhalb einer Klasse.
Beispiel Die anonyme Klasse ist eine Unterklasse von Point und initialisiert im Konstruktor einen Punkt mit den Koordinaten –1, –1. Aus diesem speziellen Punkt-Objekt lesen wir dann die Koordinaten wieder aus.
Listing 6.73
AnonymUndInnen.java, main()
java.awt.Point p = new java.awt.Point() { { x = –1; y = –1; } };
System.out.println( p.getLocation() ); // java.awt.Point[x=-1,y=-1]
System.out.println( new java.awt.Point( –1, 0 )
{
{
y = –1;
}
}.getLocation() ); // java.awt.Point[x=-1,y=-1]
Das Beispiel ist natürlich konstruiert, denn diesen Effekt können wir einfacher ohne anonyme Klasse haben:
new Point( –1, –1 ).getLocation()
|
super()
Innerhalb eines »anonymen Konstruktors« kann kein super() verwendet werden, um den Konstruktor der Oberklasse aufzurufen. Dies liegt daran, dass automatisch ein super() in den Initialisierungsblock eingesetzt wird. Die Parameter für die gewünschte Variante des (überladenen) Oberklassen-Konstruktors werden am Anfang der Definition der anonymen Klasse angegeben. Dies zeigt das zweite Beispiel im Programm AnonymUndInnen.java:
System.out.println( new Point(-1,0) { { y = –1; } }.getLocation() );
Beispiel Wir initialisieren ein Objekt BigDecimal, das beliebig große Ganzzahlen aufnehmen kann. Im Konstruktor der anonymen Unterklasse geben wir anschließend den Wert mit der geerbten toString()-Methode aus.
new java.math.BigDecimal( "12345678901234567890" ) {
{ System.out.println( toString() ); }
};
|
6.12.5 this und Vererbung
 
Wenn wir ein qualifiziertes this verwenden, dann bezeichnet C.this die äußere Klasse, also das umschließende Exemplar. Gilt jedoch die Beziehung C1.C2. ... Ci. ... Cn., haben wir mit Ci.this ein Problem, wenn Ci eine Oberklasse von Cn ist. Es geht also um den Fall, dass eine textuell umgebende Klasse zugleich auch Oberklasse ist. Das eigentliche Problem liegt darin, dass hier zweidimensionale Namensräume hierarchisch kombiniert werden. Die eine Dimension sind die Bezeichner beziehungsweise Methoden aus den lexikalisch umgebenden Klassen, die andere Dimension sind die ererbten Eigenschaften aus der Oberklasse. Hier sind beliebige Überlappungen und Mehrdeutigkeiten denkbar. Durch diese ungenaue Beziehung zwischen inneren Klassen und Vererbung kam es unter JDK 1.1 und 1.2 zu unterschiedlichen Ergebnissen.
Beispiel In der Klasse Schuh erweitert die innere Klasse Fuss den Schuh und überschreibt die Methode wasBinIch().
|
Listing 6.74
Schuh.java
public class Schuh
{
void wasBinIch()
{
System.out.println( "Ich bin der Schuh des Manitu" );
}
class Fuss extends Schuh
{
void spannung()
{
Schuh.this.wasBinIch();
}
@Override
void wasBinIch()
{
System.out.println( "Ich bin ein Schuh.Fuss" );
}
}
public static void main( String[] args )
{
new Schuh().new Fuss().spannung();
}
}
Legen wir in der main()-Funktion ein Objekt der Klasse Fuss an, dann landen wir in der Klasse Fuss und nicht in Schuh. Das heißt, die Ausgabe ist:
Ich bin der Schuh des Manitu
Das bedeutet, dass in spannung() durch Schuh.this zwar das zum Fuss-Objekt gehörende Schuh-Exemplar gemeint ist, wir aber durch die Überschreibung dennoch in der Methode aus der Klasse Fuss landen. Vor 1.2 kam als Ergebnis die erste Zeichenkette heraus. Das Ergebnis unter JDK 1.2 ist analog zu ((Schuh)this).wasBinIch().
6.12.6 Implementierung einer verketteten Liste
 
Verkettete Listen gibt es in Java seit der Java-2-Plattform als vordefinierte Klasse, sodass wir die Implementierung eigentlich nicht betrachten müssten. Da es für viele Leser jedoch noch ein Geheimnis ist, wie die dazu benötigten Pointer in Java abgebildet werden, sehen wir uns eine einfache Implementierung an. Zunächst benötigen wir eine Zelle, die Daten und eine Referenz auf das folgende Listenelement speichert. Die Zelle wird durch die Klasse Cell modelliert. Im UML-Diagramm taucht die innere Klasse im letzten Block auf.
 Hier klicken, um das Bild zu Vergrößern
Abbildung 6.10
Definition einer verketteten Liste
Listing 6.75
LinkedListDemo.java, Teil 1
class LinkedList
{
private Cell head, tail;
private static class Cell
{
Object data;
Cell next;
}
public void add( Object o )
{
Cell newCell = new Cell();
newCell.data = o;
if ( head == null ) // oder tail == null
head = tail = newCell;
else
tail = tail.next = newCell;
}
public void addAll( Object... os )
{
for ( Object o : os )
add( o );
}
@Override
public String toString()
{
StringBuilder sb = new StringBuilder( 1024 ).append( '[' );
for ( Cell cell = head; cell != null; )
{
sb.append( cell.data );
if ( cell.next != null )
sb.append( ", " );
cell = cell.next;
}
return sb.append( ']' ).toString();
}
}
Eine verkettete Liste besteht aus einer Menge von Cell-Elementen. Da diese Objekte fest mit der Liste verbunden sind, ist hier der Einsatz von geschachtelten Klassen sinnvoll. Cell ist hier statisch, kann aber auch Elementklasse sein, doch ist das egal, weil die Klasse von außen nicht sichtbar ist.
Die Liste benötigt zum Einfügen einen Verweis auf den Kopf (erstes Element) und auf das Ende (letztes Element). Um nun ein Element dieser Liste hinzuzufügen, erzeugen wir zunächst eine neue Zelle newCell. Ist tail oder head gleich null, bedeutet dies, dass es noch keine Elemente in der Liste gibt. Danach legen wir die Referenzen für Listenanfang und –ende auf das neue Objekt. Werden nun später Elemente eingefügt, hängen sie sich hinter tail. Wenn es schon Elemente in der Liste gibt, dann ist head oder tail nicht gleich null, und tail zeigt auf das letzte Element. Seine next-Referenz zeigt auf null und wird dann mit einem neuen Wert belegt, nämlich mit dem des neu beschafften Objekts newCell. Nun hängt es in der Liste, und das Ende muss noch angepasst werden. Daher legen wir die Referenz tail auch noch auf das neue Objekt.
Listing 6.76
LinkedListDemo.java, Teil 2
public class LinkedListDemo
{
public static void main( String[] args )
{
LinkedList l = new LinkedList();
l.addAll( "Hallo", "Otto" );
System.out.println( l );
}
}
6.12.7 Funktionszeiger
 
Das folgende Beispiel implementiert Funktionszeiger über Schnittstellen. Es beginnt mit der Markierungsschnittstelle Operator.
Listing 6.77
functions/Operator.java
package functions;
public interface Operator
{
// Markierungsschnittstelle
}
Sie soll Basis-Schnittstelle für Operatoren sein. Von dieser Schnittstelle wollen wir BinaryOperator ableiten, eine Schnittstelle mit einer Definition.
Listing 6.78
functions/BinaryOperator.java
package functions;
public interface BinaryOperator extends Operator
{
double calc( double a, double b );
}
Zum Test sollen die Operatoren für + und * implementiert werden:
Listing 6.79
functions/MulOperator.java
package functions;
public class MulOperator implements BinaryOperator
{
public double calc( double a, double b )
{
return a * b;
}
}
Listing 6.80
functions/AddOperator.java
package functions;
public class AddOperator implements BinaryOperator
{
public double calc( double a, double b )
{
return a + b;
}
}
Eine Sammlung von Operatoren speichert ein Operator-Manager. Bei ihm können wir dann über eine Kennung ein Berechnungs-Objekt beziehen:
Listing 6.81
functions/OperatorManager.java
package functions;
public class OperatorManager
{
public final static int ADD = 0;
public final static int MUL = 1;
private static Operator[] operators = {
new AddOperator(),
new MulOperator()
};
public static Operator getOperator( int id )
{
return operators[ id ];
}
}
Wenn wir nun einen Operator wünschen, so fragen wir den OperatorManager nach dem passenden Objekt. Die Rückgabe wird ein Operator-Objekt sein. Dies definiert jedoch noch nichts, so dass wir eine Anpassung auf BinaryOperator vornehmen sollten. Dann können wir die Funktion calc() aufrufen.
BinaryOperator op = (BinaryOperator) OperatorManager.getOperator( OperatorManager.ADD );
System.out.println( op.calc( 12, 34 ) );
So verbirgt sich hinter jeder Id eine Funktion, die wie ein Funktionszeiger verwendet werden kann. Noch interessanter ist es, die Funktionen in einen Assoziativspeicher einzusetzen und dann über einen Namen zu erfragen. Diese Implementierung nutzt kein Feld, sondern eine Datenstruktur Map. Eine Erweiterung der Idee nutzt dann auch gleich Enums und EnumMap zur Assoziation zwischen Aufzählung und Funktion.
|