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 |
| 2 Sprachbeschreibung
|  | 2.1 Elemente der Programmiersprache Java
|  |  | 2.1.1 Token
|  |  | 2.1.2 Textkodierung durch Unicode-Zeichen
|  |  | 2.1.3 Literale
|  |  | 2.1.4 Bezeichner
|  |  | 2.1.5 Reservierte Schlüsselwörter
|  |  | 2.1.6 Kommentare
|  |  | 2.1.7 Die API-Dokumentation
|  | 2.2 Anweisungen formen Programme
|  |  | 2.2.1 Anweisungen
|  |  | 2.2.2 Eine Klasse bildet den Rahmen
|  |  | 2.2.3 Die Reise beginnt am main()
|  |  | 2.2.4 Funktionsaufrufe als Anweisungen
|  |  | 2.2.5 print(), println() und printf() für Bildschirmausgaben
|  |  | 2.2.6 Ausdrucksanweisung
|  |  | 2.2.7 Erste Idee der Objektorientierung
|  |  | 2.2.8 Modifizierer
|  |  | 2.2.9 Anweisungen und Blöcke
|  | 2.3 Datentypen, Typisierung, Variablen und Zuweisungen
|  |  | 2.3.1 Primitive Datentypen im Überblick
|  |  | 2.3.2 Variablendeklarationen
|  |  | 2.3.3 Zuweisungsoperator
|  |  | 2.3.4 Variablendeklaration mit Wertinitialisierung
|  |  | 2.3.5 Wahrheitswerte
|  |  | 2.3.6 Ganzzahlige Datentypen
|  |  | 2.3.7 Die Fließkommazahlen float und double
|  |  | 2.3.8 Alphanumerische Zeichen
|  |  | 2.3.9 Gute Namen, schlechte Namen
|  | 2.4 Blöcke, Initialisierung und Sichtbarkeit
|  |  | 2.4.1 Blöcke und Anweisungen
|  |  | 2.4.2 Initialisierung von lokalen Variablen
|  |  | 2.4.3 Sichtbarkeit und Gültigkeitsbereich
|  | 2.5 Ausdrücke, Operanden und Operatoren
|  |  | 2.5.1 Arithmetische Operatoren
|  |  | 2.5.2 Unäres Minus und Plus
|  |  | 2.5.3 Zuweisung mit Operation
|  |  | 2.5.4 Präfix- oder Postfix-Inkrement und -Dekrement
|  |  | 2.5.5 Die relationalen Operatoren und die Gleichheitsoperatoren
|  |  | 2.5.6 Logische Operatoren Und, Oder, Xor, Nicht
|  |  | 2.5.7 Rang der Operatoren in der Auswertungsreihenfolge
|  |  | 2.5.8 Die Typanpassung (das Casting)
|  |  | 2.5.9 Überladenes Plus für Strings
|  | 2.6 Bedingte Anweisungen oder Fallunterscheidungen
|  |  | 2.6.1 Die if-Anweisung
|  |  | 2.6.2 Die Alternative mit einer if/else-Anweisung wählen
|  |  | 2.6.3 Die switch-Anweisung bietet die Alternative
|  | 2.7 Schleifen
|  |  | 2.7.1 Die while-Schleife
|  |  | 2.7.2 Die do-while-Schleife
|  |  | 2.7.3 Die for-Schleife
|  |  | 2.7.4 Schleifenbedingungen und Vergleiche mit ==
|  |  | 2.7.5 Ausbruch planen mit break und Wiedereinstieg mit continue
|  |  | 2.7.6 break und continue mit Sprungmarken
|  | 2.8 Methoden einer Klasse
|  |  | 2.8.1 Bestandteil einer Funktion
|  |  | 2.8.2 Signatur-Beschreibung in der Java-API
|  |  | 2.8.3 Aufruf einer Methode
|  |  | 2.8.4 Methoden ohne Parameter deklarieren
|  |  | 2.8.5 Statische Methoden (Klassenmethoden)
|  |  | 2.8.6 Parameter, Argument und Wertübergabe
|  |  | 2.8.7 Methoden vorzeitig mit return beenden
|  |  | 2.8.8 Nicht erreichbarer Quellcode bei Funktionen
|  |  | 2.8.9 Rückgabewerte
|  |  | 2.8.10 Methoden überladen
|  |  | 2.8.11 Vorgegebener Wert für nicht aufgeführte Argumente
|  |  | 2.8.12 Finale lokale Variablen
|  |  | 2.8.13 Rekursive Methoden
|  | 2.9 Weitere Operatoren
|  |  | 2.9.1 Bits und Bytes
|  |  | 2.9.2 Operationen auf Bit-Ebene
|  |  | 2.9.3 Die Verschiebeoperatoren
|  |  | 2.9.4 Ein Bit setzen, löschen, umdrehen und testen
|  |  | 2.9.5 Bit-Funktionen der Integer- und Long-Klasse
|  |  | 2.9.6 Der Bedingungsoperator
|  |  | 2.9.7 Operator vermisst
|  | 2.10 Einfache Benutzereingaben
|  | 2.11 Zum Weiterlesen
## 2.8 Methoden einer Klasse In objektorientierten Programmen interagieren zur Laufzeit Objekte miteinander und senden sich gegenseitig Nachrichten als Aufforderung, etwas zu machen. Diese Aufforderungen resultieren in einem Methodenaufruf, in dem Anweisungen stehen, die dann ausgeführt werden. Das Angebot eines Objekts, also das, was es »kann«, wird in Java durch Methoden ausgedrückt. Wir haben schon mindestens eine Methode kennengelernt: println(). Sie ist eine Methode vom out-Objekt. Ein anderes Programmstück schickt nun eine Nachricht an das out-Objekt, die println()-Methode auszuführen. Im Folgenden werden wir den aktiven Teil des Nachrichtenversendens nicht mehr so genau betrachten, sondern wir sagen nur noch, dass eine Methode aufgerufen wird. Für die Deklaration von Funktionen gibt es drei Gründe: Wiederkehrende Programmteile sollen nicht immer wieder programmiert, sondern an einer Stelle angeboten werden. Änderungen an der Funktionalität lassen sich dann leichter durchführen, wenn der Code lokal zusammengefasst ist. Komplexe Programme werden in kleine Teilprogramme zerlegt, damit die Komplexität des Programms heruntergebrochen wird. Damit ist der Kontrollfluss leichter zu erkennen. Die Operationen einer Klasse, also das Angebot eines Objekts, sind ein Grund für Funktionsdeklarationen in einer objektorientierten Programmiersprache. Daneben gibt es aber noch weitere Gründe, die für Methoden sprechen. Sie werden im Folgenden erläutert. ### 2.8.1 Bestandteil einer Funktion Eine Funktion besteht aus mehreren Bestandteilen. Dazu gehören der Methodenkopf (kurz Kopf) und der Methodenrumpf (kurz Rumpf). Der Kopf besteht aus einem Rückgabetyp (auch Ergebnistyp genannt), dem Funktionsnamen und einer optionalen Parameterliste.
Beispiel An der bekannten main()-Funktion lassen sich die Bestandteile ablesen:
    public static void main( String[] args )
    {
      System.out.println( "Wie siehst du denn aus? Biste gerannt?" );
    }
Die Funktion liefert keine Rückgabe, daher ist der »Rückgabetyp« void. (An dieser Stelle sollte bemerkt werden, dass void in Java kein Typ ist.) Der Methodenname ist main und die Parameterliste String[] args. Der Rumpf besteht nur aus der Bildschirmausgabe.
#### Signatur einer Methode Der Methodenname und die Parameterliste bestimmen die Signatur einer Methode; der Rückgabetyp gehört nicht dazu. Die Parameterliste ist durch die Anzahl Parameter, die Reihenfolge und Typen der Parameter beschrieben. Pro Klasse darf es nur eine Methode mit derselben Signatur geben, sonst meldet der Compiler einen Fehler. Da die Funktionen
    void main( String[] args )
und
    String main( String[] arguments )
die gleiche Signatur (main, String[]) besitzen – die Namen der Parameter spielen keine Rolle –, können sie nicht zusammen in einer Klasse deklariert werden. (Später werden wir sehen, dass Unterklassen durchaus gewisse Sonderfälle zulassen.)
Duck-Typing Insbesondere Skript-Sprachen, wie Python, Ruby oder Groovy, erlauben Funktionsdeklarationen ohne Parametertyp, sodass die Funktionen mit unterschiedlichen Argumenttypen aufgerufen werden können.
    add( a, b ) return a + b
Aufgrund des nicht bestimmten Parametertyps lässt sich die Funktion mit Ganzzahlen, Fließkommazahlen oder Strings aufrufen. Es ist Aufgabe der Laufzeitumgebung, diesen dynamischen Typ zu erkennen und die Addition auf dem konkreten Typ auszuführen.
### 2.8.2 Signatur-Beschreibung in der Java-API In der Java-Dokumentation sind alle Funktionen mit ihren Rückgaben und Parametern genau definiert. Betrachten wir die Dokumentation der Funktion max der Klasse Math: Hier klicken, um das Bild zu vergrößern Abbildung 2.6 Die Online-API-Dokumentation für Math.max() Die Hilfe gibt Informationen über die komplette Signatur der Methode. Der Rückgabetyp ist ein double, die Funktion heißt max(), und sie erwartet genau zwei double-Zahlen. Verschwiegen haben wir die Schlüsselwörter public static, die so genannten Modifizierer. public gibt die Sichtbarkeit an und sagt, wer diese Funktion nutzen kann. Im Fall von public bedeutet es, dass jeder diese Funktion verwenden kann. Das Gegenteil ist private: Dann kann nur das Objekt selbst diese Funktion nutzen. Das ist sinnvoll wenn Funktionen benutzt werden, um die Komplexität zu verkleinern und Teilprobleme zu lösen. Private Funktionen werden in der Regel nicht in der Hilfe angezeigt. Das Schlüsselwort static zeigt an, dass sich die Funktion mit dem Klassennamen nutzen lässt, also kein Exemplar eines Objekts nötig ist. Es gibt Funktionen, die noch andere Modifizierer und eine erweiterte Signatur besitzen. Ein weiteres Beispiel aus der API: Hier klicken, um das Bild zu vergrößern Abbildung 2.7 Ausschnitt aus der API-Dokumentation für die Klasse ServerSocket Die Sichtbarkeit dieser Funktion ist protected. Das bedeutet: Nur abgeleitete Klassen und Klassen im gleichen Verzeichnis (Paket) können diese Funktion nutzen. Ein zusätzlicher Modifizierer ist final, der in einer Vererbung der Unterklasse nicht erlaubt, die Funktion zu überschreiben und ihr neuen Programmcode zu geben. Zum Schluss folgt hinter dem Schlüsselwort throws eine Ausnahme. Diese sagt etwas darüber aus, welche Fehler die Funktion verursachen kann und worum sich der Programmierer kümmern muss. Im Zusammenhang mit der Vererbung werden wir noch über protected und final sprechen. Dem Ausnahmezustand widmen wir Kapitel 8, »Exceptions«. Die Dokumentation zeigt mit dem »Since: JDK 1.1« an, dass es die Funktion seit Java 1.1 gibt. Die Information kann auch an der Klasse festgemacht sein. ### 2.8.3 Aufruf einer Methode Da eine Methode immer einer Klasse oder einem Objekt zugeordnet ist, muss der Eigentümer beim Aufruf angegeben werden. Im Fall von System.out.println() ist println() eine Methode vom out-Objekt. Wenn wir das Maximum zweier Gleitkommazahlen mit Math.max(a, b) bilden, dann ist max() eine Funktion der Klasse Math. Für den Aufrufer ist damit immer ersichtlich, wer diese Methode anbietet, also auch, wer diese Nachricht entgegennimmt. Was der Aufrufer nicht sieht, ist die Arbeitsweise der Funktion. Der Funktionsaufruf verzweigt in den Programmcode, aber der Aufrufer weiß nicht, was dort geschieht. Er betrachtet nur das Ergebnis. Die aufgerufene Funktion wird mit ihrem Namen genannt. Die Parameterliste wird durch ein Klammerpaar umschlossen. Diese Klammern müssen auch dann gesetzt werden, wenn die Methode keine Parameter enthält. Eine Funktion wie System.out.println() gibt nichts als Ergebnis einer Berechnung zurück. Anders ist die Funktion max(); sie liefert ein Ergebnis. Damit ergeben sich vier unterschiedliche Typen von Funktionen:

Tabelle 2.8 Funktionen mit Rückgabewerten und Parametern

Funktion | Ohne Rückgabewert | Mit Rückgabewert
ohne Parameter | System.out.println() | System.currentTimeMillis()
mit Parameter | System.out.println(4) | Math.max(12, 33)
Die Funktion System.currentTimeMillis() gibt die Anzahl der verstrichenen Millisekunden ab dem 1.1.1970 als long zurück. ### 2.8.4 Methoden ohne Parameter deklarieren Die einfachste Funktion besitzt keinen Rückgabewert und keine Parameter. Im mathematischen Sinn ist dann vielleicht auch der Name »Funktion« falsch, wenn sie keinen Wert zurückliefert, aber das soll uns nicht kümmern. Im klassischen Sinn ist dieser Typ von Funktion unter dem Namen »Prozedur« bekannt, die von der Aufgabe abstrahiert, indem sie Funktionalität hinter einem Namen verbirgt. Der Begriff »Prozedur« ist jedoch in der Objektwelt nicht anzutreffen. Der Funktionscode steht in geschweiften Klammern hinter dem Kopf und bildet damit den Körper der Methode. Gibt die Methode nichts zurück, dann wird void vor dem Methodennamen geschrieben. Falls die Methode etwas zurückgibt, wird der Typ der Rückgabe anstelle von void geschrieben. Schreiben wir eine Funktion ohne Rückgabe und Parameter, die etwas auf dem Bildschirm ausgibt. Listing 2.18 FriendlyGreeter.java
    class FriendlyGreeter
    {
      static void greet()
      {
        System.out.println( "Guten Morgen. Oh, und falls wir uns nicht mehr" +
                            " sehen, guten Tag, guten Abend und gute Nacht!" );
      }

      public static void main( String[] args )
      {
        greet();
      }
    }
Tipp Die Vergabe eines Funktionsnamens ist gar nicht so einfach. Nehmen wir zum Beispiel an, wir wollen eine Funktion schreiben, die eine Datei kopiert. Spontan kommen uns zwei Wörter in den Sinn, die zu einem Funktionsnamen verbunden werden wollen: »file« und »copy«. Doch in welcher Kombination? Soll die Funktion copyFile() oder fileCopy() heißen? Wenn dieser Konflikt entsteht, sollte das Verb die Aktion anführen, unsere Wahl also auf copyFile() fallen. Funktionsnamen sollten immer das Tu-Wort vorne haben und das Was, das Objekt, an zweiter Stelle.
Eine gedrückte -Taste und ein Mausklick auf einen Bezeichner lässt Eclipse zur Deklaration springen. Ein Druck auf hat den gleichen Effekt. Steht der Cursor in unserem Beispiel auf dem Methodenaufruf greet() und wird gedrückt, dann springt Eclipse zur Definition in Zeile 3 und hebt den Funktionsnamen hervor. ### 2.8.5 Statische Methoden (Klassenmethoden) Bisher arbeiten wir nur mit statischen Methoden (auch Klassenmethoden genannt), die wir Funktionen nennen. Das besondere darin ist, dass die Methoden nicht an einem Objekt hängen und daher immer ohne explizit erzeugtes Objekt aufgerufen werden können. Das heißt, die Funktionen gehören zu Klassen an sich und sind nicht mit speziellen Objekten verbunden. Am Aufruf unserer Funktion greet() lässt sich ablesen, dass hier kein Objekt gefordert ist, mit dem die Methode verbunden ist. Das ist möglich, denn die Funktion ist als static deklariert, und innerhalb der Klasse lassen sich alle Funktionen einfach mit ihrem Namen nutzen. Statische Funktionen müssen explizit mit dem Schlüsselwort static kenntlich gemacht werden. Fehlt der Modifizierer static, so deklarieren wir damit eine Objektfunktion, die wir nur aufrufen können, wenn wir vorher ein Objekt angelegt haben. Das heben wir uns aber genauer bis zum nächsten Kapitel, »Klassen und Objekte«, auf. Die Fehlermeldung sollte aber keine Angst machen. Lassen wir von der greet()-Deklaration das static weg, und ruft die statische main()-Funktion wie jetzt ohne Aufbau eines Objektes die dann nicht mehr statische Funktion greet() auf, gibt es den Compilerfehler »Cannot make a static reference to the non-static method greet() from the type FriendlyGreeter«. Ist die statische Funktion in der gleichen Klasse wie der Aufrufer deklariert – in unserem Fall main() und greet() –, so ist der Funktionsaufruf allein mit dem Namen der Funktion eindeutig. Befinden sich jedoch Funktionsdeklaration und Funktionsaufruf in unterschiedlichen Klassen, so muss der Aufrufer den Namen der Klasse nennen; wir haben so etwas schon einmal bei Aufrufen wie Math.max() gesehen.
    class FriendlyGreeter
    {
     static void greet()
     {
      System.out.println( "Guten Morgen..." );
     }
    }
    class FriendlyGreeterCaller
    {
      public static void main( String[] args )
      {
        FriendlyGreeter.greet();
      }
    }
### 2.8.6 Parameter, Argument und Wertübergabe Einer Funktion können Werte übergeben werden, die sie dann in ihre Arbeitsweise einbeziehen kann. Der Funktion println(2001) ist zum Beispiel ein Wert übergeben worden. Sie wird damit zur parametrisierten Funktion.
Beispiel Werfen wir einen Blick auf die Funktionsdeklaration printMax(), die den größeren der beiden übergebenen Werte auf dem Bildschirm ausgibt.
    static void printMax( double a, double b )
    {
      if ( a > b )
        System.out.println( a );
      else
        System.out.println( b );
    }
Um die an Funktionen übergebenen Werte anzusprechen, gibt es formale Parameter. Von unserer Funktion printMax() sind a und b die formalen Parameter der Parameterliste. Jeder Parameter wird durch ein Komma getrennt aufgelistet, wobei für jeden Parameter der Typ angegeben sein muss; eine Kurzform wie bei der sonst üblichen Variablendeklaration wie double a, b ist nicht möglich. Jede Parametervariable einer Funktionsdeklaration muss natürlich einen anderen Namen tragen. #### Argumente (aktuelle Parameter) Der Aufrufer der Methode muss für jeden Parameter ein Argument angeben. Die im Methodenkopf deklarierten Parameter sind letztendlich lokale Variablen in der Funktion. Beim Aufruf initialisiert die Laufzeitumgebung die lokalen Variablen mit den an die Funktion übergebenen Argumenten. Rufen wir unsere parametrisierte Methode etwa mit printMax(10, 20) auf, so sind die Literale 10 und 20 Argumente (aktuelle Parameter) der Funktion. Beim Aufruf der Methode setzt die Laufzeitumgebung die Argumente in die lokalen Variablen, kopiert also den Wert 10 in die Parametervariable a und 20 in die Parametervariable b. Innerhalb des Funktionskörpers gibt es so Zugriff auf die von außen übergebenen Werte. Das Ende des Blocks bedeutet automatisch das Ende für die Parametervariablen. Der Aufrufer weiß auch nicht, wie die Parametervariablen heißen. Eine Typanpassung von int auf double nimmt der Compiler in unserem Fall automatisch vor. Die Argumente müssen vom Typ her natürlich passen, und es gelten die für die Typanpassung bekannten Regeln. #### Wertübergabe per Call by Value Wenn eine Funktion aufgerufen wird, dann gibt es in Java ein bestimmtes Verfahren, in dem jedes Argument einer Parametervariablen übergeben wird. Diese Technik heißt Parameterübergabemechanismus. Viele Programmiersprachen verfügen oft über eine ganze Reihe von verwirrenden Möglichkeiten. Java kennt nur einen einfachen Mechanismus der Wertübergabe (engl. call by value, selten auch copy by value genannt). Ein Beispiel zum Funktionsaufruf macht das deutlich:
    int i = 2;
    printMax( 10, i );
Unsere aufgerufene Funktion printMax(double a, double b) bekommt zunächst 10 in die Variable a kopiert und dann den Inhalt der Variablen i (in unserem Beispiel 2) in b. Auf keinen Fall gibt der Aufrufer Informationen über den Speicherbereich von i an die Funktion mit. In dem Moment, in dem die Methode aufgerufen wird, erfragt die Laufzeitumgebung die Belegung von i und initialisiert damit die Parametervariable b. Ändert printMax() die Variable b, so ändert dies nur die lokale Variable b (überschreibt also 2), aber die Änderung in der Funktion ist für das außenstehende i ohne Konsequenz; i bleibt weiterhin bei 2. Wegen dieser Aufrufart kommt auch der Name »copy by value« zustande. Lediglich der Wert wird übergeben (kopiert) und kein Verweis auf die Variable, wie dies Referenzen in C++ tun. #### Auswertung der Argumentenliste von links nach rechts Bei einem Methodenaufruf werden erst alle Argumente ausgewertet und anschließend der Methode übergeben. Dies bedeutet im Besonderen, dass Unterfunktionen ausgewertet und Zuweisungen gemacht werden können. Fehler führen dann zu einem Abbruch des Funktionsaufrufs. Bis zum Fehler werden alle Ausdrücke ausgewertet. ### 2.8.7 Methoden vorzeitig mit return beenden Läuft eine Methode bis zum Ende durch, dann ist die Methode damit beendet, und es geht zurück zum Aufrufer. In Abhängigkeit von einer Bedingung kann eine Methode jedoch vor dem Ende des Ablaufs mit einer return-Anweisung beendet werden. Das ist nützlich bei Methoden, die abhängig von Parametern vorzeitig aussteigen wollen. Wir können uns vorstellen, dass vor dem Ende der Funktion automatisch ein verstecktes return steht.
Beispiel Eine Funktion printSqrt() soll die Wurzel einer Zahl auf dem Bildschirm ausgeben. Bei Zahlen kleiner null erscheint eine Meldung, und die Funktion wird verlassen. Andernfalls wird die Wurzelberechnung durchgeführt:
    static void printSqrt( double d )
    {
      if ( d < 0 )
      {
        System.out.println( "Keine Wurzel aus negativen Zahlen!" );
        return;
      }
      System.out.println( Math.sqrt( d ) );
    }
Die Realisierung wäre natürlich auch mit einer else-Anweisung möglich gewesen.
Eigene Methoden können natürlich wie Standardfunktionen heißen, da sie zu unterschiedlichen Klassen gehören. ### 2.8.8 Nicht erreichbarer Quellcode bei Funktionen Folgt direkt hinter einer return-Anweisung Quellcode, so ist dieser nicht erreichbar – im Sinne von nicht ausführbar. return beendet also immer die Methode und kehrt zum Aufrufer zurück. Folgt nach dem return noch Quelltext, meldet der Compiler einen Fehler.
    public static void main( String[] args )
    {
      int i = 1;
      return;
      i = 2;              // Unreachable code!
    }
Reduzieren wir eine Anweisung bis auf das Nötigste, das Semikolon, so führt dies bisweilen zu amüsanten Ergebnissen:
    public static void main( String[] args )
    {
      ;return;;
    }
Das Beispiel enthält zwei Null-Anweisungen: eine vor dem return und eine dahinter. Doch das zweite Semikolon hinter dem return ist unzulässig, da es eine nicht erreichbare Anweisung darstellt.
Tipp In manchen Fällen ist ein return in der Mitte einer Methode gewollt. Soll etwa eine Methode in der Testphase nicht komplett durchlaufen, sondern in der Mitte beendet werden, so können wir uns mit einer Anweisung wie if ( true ) return; retten.
### 2.8.9 Rückgabewerte Funktionen wie Math.max() liefern in Abhängigkeit von den Argumenten ein Ergebnis zurück. Für den Aufrufer ist die Implementierung egal; er abstrahiert und nutzt lediglich die Methode statt eines Ausdrucks. Damit Funktionen Rückgabewerte an den Aufrufer liefern können, müssen zwei Dinge gelten: Eine Methodendeklaration bekommt einen Rückgabetyp ungleich void. Eine return-Anweisung gibt einen Wert zurück.
Beispiel Eine Funktion bildet den Mittelwert und gibt diesen zurück.
    static double avg( double x, double y )
    {
      return (x + y) / 2;
    }
Fehlt der Ausdruck und ist es nur ein einfaches return, meldet der Compiler einen Programmfehler.
Hinweis Obwohl einige Programmierer den Ausdruck gerne klammern, ist das nicht nötig. Klammern sollen lediglich komplexe Ausdrücke besser lesbar machen. Geklammerte Ausdrücke erinnern sonst nur an einen Funktionsaufruf, und diese Verwechslungsmöglichkeit sollte bei Rückgabewerten nicht bestehen.
Der Rückgabewert muss an der Aufrufstelle jedoch nicht zwingend benutzt werden. Berechnet unsere Funktion den Durchschnitt zweier Zahlen, ist es unsinnig, den Rückgabewert nicht zu verwenden. Eclipse erkennt, ob ein Rückgabetyp fehlt, und schlägt über + einen passenden Typ vor. #### Mehrere Ausstiegspunke mit return Für Methoden mit Rückgabewert gilt ebenso wie für void-Methoden, dass es mehr als ein return geben kann. Nach der Abarbeitung von return geht es im Programmcode des Aufrufers wie bei den normalen void-Methoden weiter.
Beispiel In if-Anweisungen mit weiteren else-if-Alternativen und Rücksprung ist die Semantik oft die gleiche, wenn das else-if durch ein einfaches if ersetzt wird. Der nachfolgende Programmcode zeigt das:
    if ( a == 1 )
      return 0;
    else if ( a == 2 )   // mit else
      return 1;
Äquivalent ist:
    if ( a == 1 )
      return 0;

    if ( a == 2 )        // ohne else
      return 1;
Ist die erste Bedingung wahr, so endet die Funktion, und das nachfolgende if würde sowieso nicht beachtet.
Wichtig ist nur, dass jeder denkbare Programmfluss mit einem return beendet wird. Der Compiler verfügt über ein scharfes Auge und merkt, wenn es einen Programmpfad gibt, der nicht mit einem return-Ausdruck beendet wird.
Beispiel Die Funktion isLastBitSet() soll 0 zurückgeben, wenn das letzte Bit einer Ganzzahl nicht gesetzt ist, und 1, wenn es gesetzt ist. Den Bit-Test erledigt der Und-Operator.
    static int isLastBitSet( int i )
    {
      switch ( i & 1 ) {
        case 0: return 0;
        case 1: return 1;
      }
    }
Die Funktion lässt sich nicht übersetzen, obwohl ein Bit nur gesetzt oder nicht gesetzt sein kann – dazwischen gibt es nichts.
Bei den Dingen, die für den Benutzer meistens offensichtlich sind, muss der Compiler passen, da er nicht hinter die Bedeutung sehen kann. Ähnliches würde für eine Wochen-Funktion gelten, die mit einem Ganzzahl-Argument (0 bis 6) einen Wochentag als String zurückgibt. Wenn wir die Fälle 0 = Montag bis 6 = Sonntag beachten, dann kann in unseren Augen ein Wochentag nicht 99 sein. Der Compiler kennt aber die Funktion nicht und weiß nicht, dass der Wertebereich beschränkt ist. Das Problem ließe sich mit einem default leicht beheben.
Beispiel Die Funktion posOrNeg() soll eine Zeichenkette mit der Information liefern, ob die übergebene Gleitkommazahl positiv oder negativ ist.
    static String posOrNeg( double d )
    {
      if ( d >= 0 )
        return "pos";

      if ( d < 0 )
        return "neg";
    }
Überraschenderweise ist dieser Programmcode ebenfalls fehlerhaft. Denn obwohl er offensichtlich für positive oder negative Zahlen den passenden String zurückgibt, gibt es einen Fall, den diese Funktion nicht abdeckt. Wieder gilt, dass der Compiler nicht erkennen kann, dass der zweite Ausdruck eine Negation des ersten sein soll. Es gibt aber noch einen zweiten Grund, der damit zu tun hat, dass es in Java spezielle Werte gibt, die keine Zahlen sind. Denn die Zahl d kann auch eine NaN (Not a Number) als Quadratwurzel aus einer negativen Zahl sein. Diesen speziellen Wert überprüft posOrNeg() nicht. Als Lösung für den einfachen Fall ohne NaN reicht es, aus dem zweiten if und der Abfrage einfach ein else zu machen oder die Anweisung auch gleich wegzulassen beziehungsweise mit dem Bedingungsoperator im Funktionsrumpf kompakt zu schreiben: return d >= 0 ? "pos" : "neg";. Methoden, die einen Fehlerwert wie 1 zurückliefern, sind häufig so implementiert, dass am Ende immer automatisch der Fehlerwert zurückgeliefert und dann in der Mitte die Methode bei passendem Ende verlassen wird. #### Fallunterscheidungen mit Ausschlussprinzip Eine Funktion between(x, a, b) soll testen, ob ein Wert x zwischen a (untere Schranke) und b (obere Schranke) liegt. Bei Funktionen dieser Art ist es immer sehr wichtig, darauf zu achten und zu dokumentieren, ob der Test auf echt kleiner (<) oder kleiner gleich (<=) durchgeführt werden soll. Wir wollen hier auch die Gleichheit betrachten. In der Implementierung gibt es zwei Lösungen, wobei die meisten Programmierer zur ersten Lösung neigen. Die erste Lösungsidee zeigt sich in einer mathematischen Gleichung. Wir möchten gerne a <= x <= b schreiben, doch ist dies in Java nicht erlaubt. [... im Gegensatz zur Programmiersprache Python.] So müssen wir einen Und-Vergleich anstellen, der etwa so lautet: Ist a <= x && x <= b, dann liefere true zurück. Die zweite Funktion zeigt, dass sich das Problem auch ohne Und-Vergleich durch das Ausschlussprinzip lösen lässt:
    static boolean between( int x, int a, int b )
    {
      if ( x < a )
        return false;

      if ( x <= b )
        return true;

      return false;
    }
Mit geschachtelten Anfragen sieht das dann so aus:
    static boolean between( int x, int a, int b )
    {
      if ( a <= x )
        if ( x <= b )
          return true;

      return false;
    }
### 2.8.10 Methoden überladen Eine Funktion ist gekennzeichnet durch Rückgabewert, Name, Parameter und unter Umständen durch Ausnahmefehler, die sie auslösen kann. Java erlaubt es, den Namen der Funktion beizubehalten, aber andere Parameter einzusetzen. Eine überladene Methode ist eine Funktion mit dem gleichen Namen wie eine andere Funktion, aber einer unterschiedlichen Parameterliste. Das ist auf zwei Arten möglich: Eine Funktion lautet gleich, akzeptiert aber eine unterschiedliche Anzahl von Argumenten. Eine Funktion lautet gleich, hat aber für den Compiler unterscheidbare Parametertypen. Anwendungen für den ersten Fall gibt es viele. Der Name einer Funktion soll ihre Aufgabe beschreiben, aber nicht die Typen der Parameter, mit denen sie arbeitet, extra erwähnen. Das ist bei anderen Sprachen üblich, doch nicht in Java. Sehen wir uns als Beispiel die in der Mathe-Klasse Math angebotene Funktion max() an. Sie ist mit den Parametertypen int, long, float und double deklariert – das ist viel schöner als etwa separate Funktionen maxInt() und maxDouble().
Beispiel Eine unterschiedliche Anzahl von Parametern ist ebenfalls eine sinnvolle Angelegenheit. Die Funktion avg() könnten wir so für zwei und drei Parameter deklarieren:
    static double avg( double x, double y ) {
      return (x + y) / 2;
    }
    static double avg( double x, double y, double z ) {
      return (x + y + z) / 3;
    }
Kommen wir nun zu zwei weiteren Beispielen, die etwas komplizierter sind und übersprungen werden können. #### print() und println() sind überladen Das bekannte print() und println() sind überladene Funktionen, die etwa wie folgt deklariert sind:
    class PrintStream
    {
      void print( Object arg ) { ... }
      void print( String arg ) { ... }
      void print( char[] arg ) { ... }
      ...
    }
Wird nun die Funktion print() mit irgendeinem Typ aufgerufen, dann wird die am besten passende Funktion herausgesucht. Versucht der Programmierer beispielsweise die Ausgabe eines Objekts Date, dann stellt sich die Frage, welche Methode sich darum kümmert. Glücklicherweise ist die Antwort nicht schwierig, denn es existiert auf jeden Fall eine print()-Methode, die Objekte ausgibt. Und da Date, wie auch alle anderen Klassen, eine Unterklasse von Object ist, wird print(Object) gewählt. (Natürlich kann nicht erwartet werden, dass das Datum in einem bestimmten Format – etwa nur das Jahr – ausgegeben wird, jedoch wird eine Ausgabe auf dem Schirm sichtbar.) Denn jedes Objekt kann sich durch den Namen identifizieren, und dieser würde in dem Fall ausgegeben. Obwohl es sich so anhört, als ob immer die Funktion mit dem Parametertyp Object aufgerufen wird, wenn der Datentyp nicht angepasst werden kann, ist dies nicht ganz richtig. Wenn der Compiler keine passende Klasse findet, dann wird die nächste Oberklasse im Ableitungsbaum gesucht, für die in unserem Fall eine Ausgabefunktion existiert. #### Negative Beispiele und schlaue Leute Oft verfolgt auch die Java-Bibliothek die Strategie mit gleichen Namen und unterschiedlichen Typen. Es gibt allerdings einige Ausnahmen. In der Grafik-Bibliothek finden sich die folgenden drei Funktionen: draw String( String str, int x, int y ) draw Chars( char[] data, int offset, int length, int x, int y ) draw Bytes( byte[] data, int offset, int length, int x, int y ) Das ist äußerst hässlich und schlechter Stil. Ein anderes Beispiel findet sich in der Klasse DataOutputStream. Hier heißen die Methoden etwa writeInt(), writeChar() und so weiter. Obwohl wir dies auf den ersten Blick verteufeln würden, ist diese Namensgebung sinnvoll. Ein Objekt vom Typ DataOutputStream dient zum Schreiben von primitiven Werten in einen Datenstrom, und davon gibt es bekannterweise einige, mit unterschiedlichen Längen. Gäbe es in DataOutputStream die überladenen Methoden write(byte), write(short), write(int), write(long) und write(char) und würden wir sie mit write(21) füttern, dann hätten wir das Problem, dass eine Typkonvertierung die Daten automatisch anpassen und der Datenstrom mehr Daten beinhalten würde, als wir wünschen. Denn write(21) ruft nicht etwa write(short) auf und schreibt zwei Bytes, sondern write(int) und schreibt somit vier Bytes. Um also die Übersicht über die geschriebenen Bytes zu behalten, ist eine ausdrückliche Kennzeichnung der Datentypen in manchen Fällen gar nicht so dumm. ### 2.8.11 Vorgegebener Wert für nicht aufgeführte Argumente Überladene Funktionen lassen sich gut verwenden, wenn vorinitialisierte Werte bei nicht vorhandenen Argumenten genutzt werden sollten. Ist also ein Parameter nicht belegt, soll ein Standardwert eingesetzt werden. Um das zu erreichen, überladen wir einfach die Funktion und rufen die andere Funktion mit dem Standardwert passend auf. (Die Sprache C++ definiert in der Sprachgrammatik eine Möglichkeit, die wir in Java nicht haben.)
Beispiel Zwei überladene Funktionen, tax(double cost, double taxRate) und tax(double cost), sollen die Steuer berechnen. Wir möchten, dass der Steuersatz automatisch 19 ist, wenn die Funktion tax(double cost) aufgerufen wird und der Steuersatz nicht explizit gegeben ist; im anderen Fall können wir taxRate beliebig wählen.
    static double tax( double cost, double taxRate )
    {
      return cost * taxRate / 100;
    }
    static double tax( double cost )
    {
      return tax( cost, 19.0 );
    }
### 2.8.12 Finale lokale Variablen In einer Methode können Parameter oder lokale Variablen mit dem Modifizierer final deklariert werden. Dieses zusätzliche Schlüsselwort verbietet nochmalige Zuweisungen an diese Variable, sodass sie nicht mehr verändert werden kann.
    static void foo( final int a )
    {
        int i = 2;
        final int j = 3;
        i = 3;
    //  j = 4;       führt zu einem Fehler
    //  a = 2;       führt zu einem Fehler
    }
#### Aufgeschobene Initialisierung Java erlaubt bei finalen Werten eine aufgeschobene Initialisierung. Das heißt, dass nicht zwingend zum Zeitpunkt der Variablendeklaration ein Wert zugewiesen werden muss. Dies kann auch genau einmal im Programmcode geschehen. Folgendes ist gültig:
    final int a;
    a = 2;
Obwohl auch Objektvariablen und Klassenvariablen final sein können, gibt es dort nur beschränkt eine aufgeschobene Initialisierung. Bei der Deklaration müssen wir die Variablen entweder direkt belegen oder im Konstruktor zuweisen. Wir werden uns dies später noch einmal genauer ansehen. Werden finale Variablen vererbt, so können Unterklassen diesen Wert auch nicht mehr überschreiben. (Das wäre ein Problem, aber vielleicht auch ein Vorteil für manche Konstanten.) #### Final deklarierte Referenz-Parameter und das fehlende const Wir haben gesehen, dass finale Variablen dem Programmierer vorgeben, dass er Variablen nicht beschreiben darf. Das heißt, Zuweisungen sind tabu. Dabei ist es egal, ob die Parametervariable vom primitiven Typ oder vom Referenztyp ist. Bei einer Funktionsdeklaration der folgenden Art wäre also eine Zuweisung an i und auch an s verboten:
    public void foo( final int i, final String s )
Ist die Parametervariable ein Referenztyp (und nicht final), so würden wir mit einer Zuweisung den Verweis auf das ursprüngliche Objekt verlieren, und das wäre wenig sinnvoll.
    public void foo( String s )
    {
      s = "Keine Feier ohne Geier.";
    }
Halten wir fest: Ist ein Parameter mit final deklariert, sind keine Zuweisungen möglich. final verbietet aber keine Änderungen an Objekten – und so könnte final im Sinne der Übersetzung »endgültig« verstanden werden. Mit der Referenz des Objekts können wir sehr wohl den Zustand verändern. So ändert die folgende foo()-Funktion die x-Koordinate eines Point-Objekts, egal, ob p final ist oder nicht.
    public static void foo( final Point p )
    {
      p.x = 2;
    }
final erfüllt demnach nicht die Aufgabe, schreibende Objektzugriffe zu verhindern. Eine Methode mit übergebenen Referenzen kann also Objektveränderungen vornehmen, wenn es etwa setXXX()-Methoden oder Variablen gibt, auf die zugegriffen werden kann. Die Dokumentation muss also immer ausdrücklich beschreiben, wann die Funktion den Zustand eines Objekts modifiziert. In C++ gibt es für Parameter den Zusatz const, an dem der Compiler erkennen kann, dass Objektzustände nicht verändert werden sollen. Ein Programm nennt sich »const-korrekt«, wenn es niemals ein konstantes Objekt verändert. Dieses const ist in C++ eine Erweiterung des Objekttyps, die es in Java nicht gibt. Zwar haben die Java-Entwickler das Schlüsselwort const reserviert, doch genutzt wird es bisher nicht. #### final in der Vererbung In der Vererbung spielt das final bei Parametern keine Rolle. Wir können es als zusätzliche Information für die jeweilige Methode betrachten. Eine Unterklasse kann demnach beliebig das final hinzufügen oder auch wegnehmen. Alte Bibliotheken lassen sich so leicht weiterverwenden. ### 2.8.13 Rekursive Methoden Wir wollen den Einstieg in die Rekursion mit einem kurzen Beispiel beginnen. Auf dem Weg durch den Wald begegnet uns eine Fee. Sie sagt zu uns: »Du hast drei Wünsche frei.« Tolle Situation. Um das ganze Unglück aus der Welt zu räumen, entscheiden wir uns nicht für eine egozentrische Wunscherfüllung, sondern für die sozialistische: »Ich möchte Frieden für alle, Gesundheit und Wohlstand für jeden.« Und schwupps, so war es geschehen, und alle lebten glücklich bis ... Einige Leser werden vielleicht die Hand vor den Kopf schlagen und sagen: »Quatsch! Ein Haus, ein Auto und einen Lebenspartner, der die Trägheit des Morgens duldet.« Glücklicherweise können wir das Dilemma mit der Rekursion lösen. Die Idee ist einfach – und in unseren Träumen schon erprobt –, sie besteht nämlich darin, den letzten Wunsch als »Nochmal drei Wünsche frei« zu formulieren.
Beispiel Eine kleine Wunsch-Funktion:
    static void fee()
    {
      wunsch();
      wunsch();
      fee();
    }
Durch den dauernden Aufruf der fee()-Funktion haben wir unendlich viele Wünsche frei. Rekursion ist also das Aufrufen der eigenen Methode, in der wir uns befinden. Dies kann auch über einen Umweg funktionieren. Das nennt sich dann nicht mehr direkte Rekursion, sondern indirekte Rekursion. Sie ist ein sehr alltägliches Phänomen, das wir auch von der Rückkopplung Mikrofon/Lautsprecher oder dem Blick mit einem Spiegel in den Spiegel kennen. #### Abbruch der Rekursion Wir müssen nun die Fantasie-Programme (deren Laufzeit und Speicherbedarf auch sehr schwer zu berechnen sind) gegen Java-Funktionen austauschen.
Beispiel Eine Endlos-Rekursion: Listing 2.19 EndlessRecursion.java, down()
    static void down( int n )
    {
      System.out.print( n + ", " );
      down( n – 1 );
    }
Rufen wir down(10) auf, dann wird die Zahl 10 auf dem Bildschirm ausgegeben und anschließend down(9) aufgerufen. Führen wir das Beispiel fort, so ergibt sich eine endlose Ausgabe, die so beginnt:
    10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, –1, –2, ...
An dieser Stelle erkennen wir, dass Rekursion prinzipiell etwas Unendliches ist. Für Programme ist dies aber ungünstig. Wir müssen daher ähnlich wie bei Schleifen eine Abbruchbedingung formulieren und dann keinen Rekursionsaufruf mehr starten. Die sieht so aus, dass eine Fallunterscheidung das Argument prüft und mit return die Abarbeitung beendet. Listing 2.20 Recursion.java, down1()
    static void down1( int n )
    {
      if ( n <= 0 )              // Rekursionsende
        return;

      System.out.print( n + ", " );
      down1( n – 1 );
    }
Die down1()-Funktion ruft jetzt nur noch so lange down1(n – 1) auf, wie das n größer null ist. Das ist die Abbruchbedingung einer Rekursion. #### Unterschiedliche Rekursionsformen Ein Kennzeichen der bisherigen Programme war, dass nach dem Aufruf der Rekursion keine Anweisung stand, sondern die Methode mit dem Aufruf beendet wurde. Diese Rekursionsform nennt sich Endrekursion. Diese Form ist verhältnismäßig einfach zu verstehen. Schwieriger sind Rekursionen, bei denen hinter dem Methodenaufruf Anweisungen stehen. Betrachten wir folgende Methoden, von denen die erste bekannt und die zweite neu ist: Listing 2.21 Recursion.java, down1() und down2()
    static void down1( int n )
    {
      if ( n <= 0 )   // Rekursionsende
        return;

      System.out.print( n + ", " );

      down1( n – 1 );
    }

    static void down2( int n )
    {
      if ( n <= 0 )   // Rekursionsende
        return;

      down2( n – 1 );

      System.out.print( n + ", " );
    }
Der Unterschied besteht darin, dass down1() zuerst die Zahl n ausgibt und anschließend rekursiv down1() aufruft. Die Funktion down2() steigt jedoch erst immer tiefer ab, und die Rekursion muss beendet sein, bis es zum ersten print() kommt. Daher gibt im Gegensatz zu down1() die Funktion down2() die Zahlen in aufsteigender Reihenfolge aus:
    1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
Dies ist einleuchtend, wenn wir die Ablaufreihenfolge betrachten. Beim Aufruf down2(10) ist der Vergleich von n mit null falsch, also wird ohne Ausgabe wieder down2(9) aufgerufen. Ohne Ausgabe deshalb, da print() ja erst nach dem Funktionsaufruf steht. Es geht rekursiv tiefer, bis n gleich null ist. Dann endet die letzte Funktion mit return, und die Ausgabe wird nach dem down2(), dem Aufrufer, fortgeführt. Dort ist print() die nächste Anweisung. Da wir nun noch tief verschachtelt stecken, gibt print(n) die Zahl 1 aus. Dann ist die Funktion down2() wieder beendet (ein unsichtbares, nicht direkt geschriebenes return), und sie springt zum Aufrufer zurück. Das war wieder die Funktion down2(), aber mit der Belegung n = 2. Das geht so weiter, bis es zurück zum Aufrufer kommt, der down(10) aufgerufen hat, zum Beispiel die main()-Funktion. Der Trick bei der Sache besteht nun darin, dass jede Funktion ihre eigene lokale Variable besitzt. Die Tastenkombination + + zeigt die Aufrufhierarchie an. So ist zu sehen, wer eine Funktion aufruft. In den Aufrufen von down2() taucht also wiederum wegen des rekursiven Aufrufs down2() auf sowie main(). ### 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