6.11 Geschachtelte (innere) Klassen, Schnittstellen, Aufzählungen

Bisher haben wir Klassen, Schnittstellen und Aufzählungen kennengelernt, die entweder alleine in der Datei oder zusammen mit anderen Typen in einer Datei deklariert wurden. Es gibt darüber hinaus die Möglichkeit, eine Klasse, Aufzählung oder Schnittstelle in andere Typdeklarationen hineinzunehmen. Für eine Klasse In, die in eine Klasse Out gesetzt wird, sieht das zum Beispiel so aus:

class Out { 
  class In { 
  } 
}

Eine geschachtelte Klasse, die so eingebunden wird, heißt »innere Klasse«. Im Folgenden wollen wir nicht mehr ständig betonen, dass auch Schnittstellen als Typen eingebettet werden können und bleiben bei der einfachen Sprachweise »innere Klassen«. (Aufzählungen werden vom Compiler zu Klassen und müssen daher nicht unbedingt gesondert behandelt werden.)

Die Java-Spezifikation beschreibt vier Typen von inneren Klassen, die im Folgenden beschrieben werden. Egal, wie sie deklariert werden, es ist eine enge Kopplung der Typen, und der Name des inneren Typs muss sich vom Namen des äußeren Typs unterscheiden.

class Out 
{ 
 static class In {} 
}

class Out 
{ 
 class In { } 
}

class Out 
{ 
 Out() 
 { 
  class In { } 
 } 
}

new Runnable() { 
  public void run() { } 
};

6.11.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, nur bilden sie quasi ein kleines Unterpaket mit eigenem Namensraum. Insbesondere sind zur Erzeugung von Exemplaren von statischen inneren Klassen nach diesem Muster keine Objekte der äußeren Klasse nötig. (Die weiteren inneren Typen, die wir kennenlernen wollen, sind alle nicht statisch und benötigen einen Verweis auf das äußere Objekt.) Sun betont in der Spezifikation der Sprache, dass die statischen inneren Klassen keine »echten« inneren Klassen sind, doch um die Sprache einfach zu halten, bleiben wir bei »statischen inneren Typen«.

Deklarieren wir Lamp als äußere Klasse und Bulb als eine innere statische Klasse.

Listing 6.92 com.tutego.insel.inner.Lamp.java, Lamp

public class Lamp 
{ 
  static String s = "Huhu"; 
  int i = 1; 
 
  static class Bulb 
  { 
    void out() 
    { 
      System.out.println( s ); 
//      System.out.println( i );          // Fehler, da i nicht statisch 
    } 
  } 
 
  public static void main( String[] args ) 
  { 
    Bulb bulb = new Lamp.Bulb();  // oder Lamp.Bulb bulb = ... 
    bulb.out(); 
  } 
}

Die statische innere Klasse Bulb besitzt Zugriff auf alle anderen statischen Eigenschaften der äußeren Klasse Lamp, in unserem Fall die Variable s. 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. Der Zugriff von außen auf innere Klassen gelingt mit der Schreibweise ÄußereKlasse.InnereKlasse; der Punkt wird also so verwendet, wie wir es von den Paketen als Namensraum gewöhnt sind. Die innere Klasse muss einen anderen Namen als die äußere haben. Erlaubt sind die Modifizierer abstract, final und Sichtbarkeitsmodifizierer.

Umsetzung der inneren Typen

Die Sun-Entwickler haben es geschafft, die Einführung von inneren Klassen ohne Änderung der virtuellen Maschine über die Bühne zu bringen. Der Compiler generiert aus den inneren Typen nämlich einfach normale Klassendateien, die jedoch mit einigen Spezialfunktionen ausgestattet sind. Für die geschachtelten inneren Typen generiert der Compiler neue Namen nach dem Muster: ÄußererTyp$InnererTyp, das heißt: ein Dollar-Zeichen trennt die Namen von äußerem und innerem Typ.

6.11.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.) Deklarieren wir eine innere Mitgliedsklasse Room in House:

Listing 6.93 com.tutego.insel.inner.House.java, Ausschnitt

class House 
{ 
  private String owner = "Ich"; 
 
  class Room 
  { 
    void ok() 
    { 
      System.out.println( owner ); 
    } 
    // static void error() { } 
  } 
}

Ein Exemplar der Klasse Room hat Zugriff auf alle Eigenschaften von House, auch der privaten. Eine wichtige Eigenschaft ist, dass innere Mitgliedsklassen selbst keine statischen Eigenschaften deklarieren dürfen. Der Versuch in unserem Fall führt zum Compilerfehler:

The method error cannot be declared static; static methods can only be declared  
in a static or top level type

Exemplare innerer Klassen erzeugen

Um ein Exemplar von Room 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.

In einem Konstruktor oder in einer Objektmethode der äußeren Klassen kann einfach mit dem new-Operator ein Exemplar der inneren Klasse erzeugt werden. Kommen wir von außerhalb – oder von einem statischen Block der äußeren Klasse – 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 spezielle Form für die Erzeugung mit new vor, die folgendes allgemeine Format besitzt:

referenz.new InnereKlasse(...)

Dabei ist ref eine Referenz vom Typ der äußeren Klasse. Um in der main()-Funktion vom Haus ein Room-Objekt aufzubauen, schreiben wir:

Listing 6.94 com.tutego.insel.inner.House.java, main()

House h = new House(); 
Room  r = h.new Room();

oder auch in einer Zeile:

Room  r = new House().new Room();

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.

Listing 6.95 com.tutego.insel.inner.HouseRoomChair.java, HouseRoomChair

class HouseRoomChair 
{ 
  String s = "House"; 
 
  class Room 
  { 
    String s = "Room"; 
 
    class Chair 
    { 
      String s = "Chair"; 
      void out() 
      { 
        System.out.println( s );                     // Chair 
        System.out.println( this.s );                // Chair 
        System.out.println( Chair.this.s );          // Chair 
        System.out.println( Room.this.s );           // Room 
        System.out.println( HouseRoomChair.this.s ); // House 
      } 
    } 
  } 
 
  public static void main( String[] args ) 
  { 
    new House().new Room().new Chair().out(); 
  } 
}

Betrachten wir das obere Beispiel, dann lassen sich Objekte für die inneren Klassen House, Room und Chair wie folgt erstellen:

House h            = new House();    // Exemplar von House 
House.Room r       = h.new Room();   // Exemplar von Room in h 
House.Room.Chair c = r.new Chair();  // Exemplar von Chair in r 
c.out();                             // Methode von Chair

Damit ist auch deutlich geworden, dass die Qualifizierung mit dem Punkt bei House.Room.Chair nicht automatisch bedeutet, dass House ein Paket mit dem Unterpaket Room ist, in dem die Klasse Chair 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.

Vom Compiler generierte Klassendateien

Für das Beispiel House und Room erzeugt der Compiler die Dateien House.class und House$Room.class. Damit die innere Klasse an die Attribute der äußeren gelangt, 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 nichtstatische Attribute der äußeren Klasse zugreifen. Für die innere Klasse ergibt sich folgendes Bild in House$Room.class:

class HouseBorder$Room 
{ 
  final House this$0; 
 
  House$Room( House house ) 
  { 
    this$0 = house; 
  } 
  // ... 
}

Die Variable this$0 referenziert das Exemplar House.this, also die zugehörige äußere Klasse. Die Konstruktoren der inneren Klasse erhalten einen zusätzlichen Parameter vom Typ House, um die this$0-Variable zu initialisieren.

Zugriffsrechte

Eine innere Klasse kann auf alle Attribute der äußeren Klasse zugreifen. Da innere Klassen als ganz normale Klassen übersetzt werden, stellt sich allerdings die Frage, wie sie das genau macht. Auf öffentliche Variablen kann jede andere Klasse ohne Tricks zugreifen, so auch die innere. Und da eine innere Klasse als normale Klassendatei im gleichen Paket sitzt, kann sie ebenfalls ohne Verrenkungen auf paketsichtbare und protected-Eigenschaften der äußeren Klasse zugreifen. Eine innere Klasse kann jedoch auch auf private Eigenschaften zurückgreifen, eine Designentscheidung, die sehr umstritten ist und lange kontrovers diskutiert wurde. Doch wie ist das zu schaffen, ohne gleich die Zugriffsrechte des Attributs zu ändern? Der Trick ist, dass der Compiler eine synthetische Funktion in der äußeren Klasse einführt:

class House 
{ 
  private String owner; 
 
  static String access$0( House house ) 
  { 
    return house.owner; 
  } 
}

Die statische Funktion access$0() ist der Helfershelfer, der für ein gegebenes House das private Attribut nach außen gibt. Da die innere Klasse einen Verweis auf die äußeren Klasse pflegt, gibt sie diesen beim gewünschten Zugriff mit, und die access$0()-Methode erledigt den Rest.

Pro von der inneren Klasse genutztes privates Attribut erzeugt der Compiler eine solche Funktion. Wenn wir eine weitere private Variable int size hinzunehmen, würde der Compiler ein int access$1(House) generieren.

6.11.3 Lokale Klassen

Lokale Klassen sind ebenfalls innere Klassen, die jedoch nicht einfach im Rumpf einer Klasse wie eine Eigenschaft, sondern direkt in Anweisungsblöcken von Methoden, Konstruktoren und Initialisierungsblöcken gesetzt werden. Lokale Schnittstellen sind nicht möglich. So soll im folgenden Beispiel die main()-Methode eine innere Klasse mit einem Konstruktor besitzen, der auf die finale Variable j zugreift.

Listing 6.96 com.tutego.insel.inner.FunInside.java, FunInside

public class FunInside 
{ 
  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 Deklaration der inneren Klasse In ist wie eine Anweisung eingesetzt. Ein Sichtbarkeitsmodifizierer ist ungültig, und die Klasse darf keine Klassenmethoden und allgemeinen statischen Variablen deklarieren (finale Konstanten schon).

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 keine Objektmethode der äußeren Klasse aufrufen. Eine weitere Einschränkung im Vergleich zu den Elementklassen ist, dass die Modifizierer public, protected, private und static nicht erlaubt sind.

6.11.4 Anonyme innere Klassen

Anonyme Klassen gehen noch einen Schritt weiter als lokale Klassen. Sie haben keinen Namen und erzeugen immer automatisch ein Objekt; Klassendeklaration und Objekterzeugung sind zu einem Sprachkonstrukt verbunden. Die allgemeine Notation ist folgende:

new KlasseOderSchnittstelle() { /* Eigenschaften der inneren Klasse */ }

In dem Block geschweifter Klammern lassen sich nun Methoden und Attribute deklarieren oder Methoden überschreiben. Hinter new steht der Name einer Klasse oder Schnittstelle:

• new Klassenname(Optionale Argumente) { ... }. Steht hinter new ein Klassentyp, dann ist die anonyme Klasse eine Unterklasse von Klassenname. Es lassen sich mögliche Argumente für den Konstruktor der Basisklasse angeben, den die anonyme innere Klasse automatisch mit super() aufruft.

• new Schnittstellenname() { ... }. Steht hinter new der Name einer Schnittstelle, dann erbt die anonyme Klasse von Object und implementiert die Schnittstelle Schnittstellenname. Implementiert sie nicht die Operationen der Schnittstelle, ist das ein Fehler; wir hätten nichts davon, denn dann hätten wir eine abstrakte innere Klasse, von der sich kein Objekt erzeugen lässt.

Für anonyme innere Klassen gilt die Einschränkung, dass keine zusätzlichen extends- oder implements-Angaben möglich sind. Ebenso sind keine eigenen Konstruktoren möglich. Es gelten die gleichen Einschränkungen bezüglich der Methoden: es sind keine statischen Methoden und keine statischen nicht-finalen Variablen erlaubt.

Wir wollen eine innere Klasse schreiben, die Unterklasse von java.awt.Point ist. Sie soll die toString()-Methode überschreiben.

Listing 6.97 com.tutego.insel.inner.InnerToStringPoint.java, main()

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 aufgebaut wird, fehlt der Name der inneren Klasse. Das einzige Exemplar dieser anonymen Klasse lässt sich über die Variable p weiterverwenden.

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, folgen 2, 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 10, »Threads und nebenläufige Programmierung«, 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() {     // Anonyme Klasse extends Object implements 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():

Listing 6.98 com.tutego.insel.inner.FirstThread, main()

new Thread( new Runnable() { 
  public void run() { 
    for ( int i = 0; i < 10; i++ ) 
      System.out.printf( "%d ", i ); 
  }; 
} ).start(); 
 
for ( int i = 0; i < 10; i++ ) 
  System.out.printf( "%d ", i );

In der Ausgabe wird zum Beispiel Folgendes erscheinen (hier komprimiert):

0 0 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9

Der neue Thread beginnt mit der 0 und wird dann unterbrochen. Der main-Thread kann in einem Zug 0 bis 9 ausgeben. Danach folgt wieder der erste Thread und kann den Rest ausgeben. Ausführliche Informationen zu Threads vermittelt Kapitel 10.

Konstruktoren innerer anonymer Klassen

Da anonyme Klassen keinen Namen haben, muss für Konstruktoren ein anderer Weg gefunden werden. Hier helfen Exemplarinitialisierungsblöcke, das heißt, die Blöcke in geschweiften Klammern direkt innerhalb einer Klasse.

Dazu ein 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.99 com.tutego.insel.inner.AnonymousAndInside.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]

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 Deklaration der anonymen Klasse angegeben. Dies zeigt das zweite Beispiel.

System.out.println( new Point(-1, 0) { { y = –1; } }.getLocation() );

new java.math.BigDecimal( "12345678901234567890" ) { 
  { System.out.println( toString() ); } 
};

6.11.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 besteht 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 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.

Im nächsten Beispiel soll von der Klasse Shoe die innere Klasse LeatherBoot den Shoe erweitern und die Methode out() überschreiben.

Listing 6.100 com.tutego.insel.inner.Shoe.java, Shoe

public class Shoe 
{ 
  void out() 
  { 
    System.out.println( "Ich bin der Schuh des Manitu." ); 
  } 
 
  class LeatherBoot extends Shoe 
  { 
    void what() 
    { 
      Shoe.this.out(); 
    } 
 
    @Override 
    void out() 
    { 
      System.out.println( "Ich bin ein Shoe.LeatherBoot." ); 
    } 
  } 
 
  public static void main( String[] args ) 
  { 
    new Shoe().new LeatherBoot().what(); 
  } 
}

Legen wir in der main()-Funktion ein Objekt der Klasse LeatherBoot an, dann landen wir bei what() in der Klasse LeatherBoot, was Shoe.this.out() ausführt. Interessant ist aber, dass hier kein dynamisch gebundener Aufruf an out() vom LeatherBoot-Objekt erfolgt, sondern die Ausgabe von Shoe ist:

Ich bin der Schuh des Manitu.

Die überschriebene Ausgabe von LeatherBoot liefert die ähnliche aussehende Anweisung ((Shoe)this).out(). Vor 1.2 kam als Ergebnis immer diese Zeichenkette heraus.

Ihr Kommentar