Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort
1 Java ist auch eine Sprache
2 Sprachbeschreibung
3 Klassen und Objekte
4 Der Umgang mit Zeichenketten
5 Mathematisches
6 Eigene Klassen schreiben
7 Angewandte Objektorientierung
8 Exceptions
9 Generics, innere Klassen
10 Die Klassenbibliothek
11 Threads und nebenläufige Programmierung
12 Datenstrukturen und Algorithmen
13 Raum und Zeit
14 Dateien und Datenströme
15 Die eXtensible Markup Language (XML)
16 Grafische Oberflächen mit Swing
17 Grafikprogrammierung
18 Netzwerkprogrammierung
19 Verteilte Programmierung mit RMI und Web–Services
20 JavaServer Pages und Servlets
21 Applets
22 Midlets und die Java ME
23 Datenbankmanagement mit JDBC
24 Reflection und Annotationen
25 Logging und Monitoring
26 Sicherheitskonzepte
27 Java Native Interface (JNI)
28 Dienstprogramme für die Java-Umgebung
Stichwort
Download: - ZIP, ca. 14,1 MB
Buch bestellen
Ihre Meinung?
<< zurück | Galileo Computing / <openbook> / Java-Insel | vor >>
Java ist auch eine Insel (8. Auflage) von Christian Ullenboom Programmieren mit der Java Standard Edition Version 6
Java ist auch eine Insel (8. Aufl.) 8., aktual. Auflage, geb., mit DVD 1.475 S., 49,90 Euro Galileo Computing ISBN 978-3-8362-1371-4 |
| 9 Generics, innere Klassen
|  | 9.1 Generische Datentypen
|  |  | 9.1.1 Einfache Klassenschablonen
|  |  | 9.1.2 Einfache Methodenschablonen
|  |  | 9.1.3 Umsetzen der Generics, Typlöschung und Raw-Types
|  |  | 9.1.4 Generics und Arrays
|  |  | 9.1.5 Einschränken der Typen
|  |  | 9.1.6 Generics und Vererbung, Invarianz
|  |  | 9.1.7 Wildcards
|  | 9.2 Geschachtelte (innere) Klassen, Schnittstellen, Aufzählungen
|  |  | 9.2.1 Statische innere Klassen und Schnittstellen
|  |  | 9.2.2 Mitglieds- oder Elementklassen
|  |  | 9.2.3 Lokale Klassen
|  |  | 9.2.4 Anonyme innere Klassen
|  |  | 9.2.5 this und Vererbung
## 9.2 Geschachtelte (innere) Klassen, Schnittstellen, Aufzählungen Bisher haben wir Klassen, Schnittstellen und Aufzählungen kennengelernt, die entweder allein 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.
statische innere Klasse |
    class Out
    {
     static class In {}
    }
Mitgliedsklasse |
    class Out
    {
     class In { }
    }
lokale Klasse |
    class Out
    {
     Out()
     {
      class In { }
     }
    }
anonyme innere Klasse |
    new Runnable() {
      public void run() { }
    };
Hinweis Das Gegenteil von geschachtelten Klassen, also das, womit wir uns bisher die die ganze Zeit beschäftigt haben, heißt »Top-Level-Klasse«. Normale Top-Level-Typen können paketsichtbar oder public sein; innere Klassen dürfen public, paketsichtbar, protected und private sein. Die Laufzeitumgebung kennt nur Top-Level-Klassen, und geschachtelte innere Klassen werden letztendlich zu ganz »normalen« Klassendeklarationen.
### 9.2.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 9.7 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 );   // Compiler error because i is not static
        }
      }
      public static void main( String[] args )
      {
        Bulb bulb = new Lamp.Bulb();  // or 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 gesonderte 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 so genannten synthetischen Methoden 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. ### 9.2.2 Mitglieds- oder Elementklassen Eine Mitgliedsklasse (engl. member class), auch Elementklasse genannt, ist ebenfalls vergleichbar mit einem Attribut, nur ist sie nicht statisch. (Statische innere Klassen lassen sich aber auch als statische Mitgliedsklassen bezeichnen.) Deklarieren wir eine innere Mitgliedsklasse Room in House: Listing 9.8 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 die 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 9.9 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 9.10 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();
      }
    }
Hinweis Elementklassen können beliebig geschachtelt sein, und da der Name eindeutig ist, gelangen wir mit Klassenname.this immer an die jeweilige Eigenschaft.
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 beachtet 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 nicht-statische 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 eine innere Klasse als ganz normale Klasse übersetzt wird, 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ßere Klasse pflegt, gibt sie diesen beim gewünschten Zugriff mit, und die access$0()-Funktion 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.
Hinweis Problematisch ist das bei Klassen, die in ein Paket eingeschmuggelt werden, denn die access$XXX()-Funktionen sind paketsichtbar. Es reicht dann ein Exemplar der äußeren Klasse, um über einen access$XXX()-Aufruf auf die privaten Variablen zuzugreifen, die eine innere Klasse nutzt. Glücklicherweise lässt sich gegen eingeschleuste Klassen in Java-Archiven leicht etwas unternehmen – sie müssen nur abgeschlossen werden, was bei Java sealing heißt.
### 9.2.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()-Funktion eine innere Klasse mit einem Konstruktor besitzen, der auf die finale Variable j zugreift. Listing 9.11 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 );    // Compiler error because i is not 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. ### 9.2.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 9.12 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.
Hinweis Eine innere Klasse kann Methoden der Oberklasse überschreiben oder Operationen aus Schnittstellen implementieren. Neue Eigenschaften anzubieten, wäre zwar zulässig, 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. (Wir lassen die Tatsache, dass eine Anwendung mit Reflection auf die Methoden zugreifen kann, außen vor.)
#### 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 11, »Threads und nebenläufige Programmierung«, genau beschrieben.) Die Schnittstelle Runnable schreibt eine Operation run() vor, in die 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 9.13 com.tutego.insel.inner.FirstThread, main()
    new Thread( new Runnable() {
      @Override 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 11. + 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, 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 9.14 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() );
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() ); }
    };
### 9.2.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 9.15 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 ähnlich aussehende Anweisung ((Shoe)this).out(). Vor Version 1.2 kam als Ergebnis immer diese Zeichenkette heraus. ### Ihr Kommentar Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen. >> Zum Feedback-Formular
<< zurück | <top> | vor >>
Zum Katalog
Java ist auch eine Insel Jetzt bestellen
Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen? Ihre Meinung
Tipp
| Coding for Fun
Buchempfehlungen
| Objektorientierte Programmierung
| Einstieg in Eclipse 3.4
| Java 6 lernen mit Eclipse
| NetBeans Platform 6
| Java und XML
| Visual C# 2008
| IT-Handbuch für Fachinformatiker
| C++ von A bis Z
Shopping
Versandkostenfrei bestellen in Deutschland und Österreich Info

Copyright © Galileo Press 2009
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.

[Galileo Computing]
Galileo Press, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de