Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage
<< | < | > | >> | API | Kapitel 12 - Exceptions

## 12.3 Weitergabe von Exceptions

- 12.3 Weitergabe von Exceptions
  - 12.3.1 Die catch-or-throw-Regel
  - 12.3.2 Weitergabe einer Exception
    - Die Klasse RuntimeException
  - 12.3.3 Auslösen von Ausnahmen

### 12.3.1 Die catch-or-throw-Regel

Bei der Behandlung von Ausnahmen in Java gibt es die Grundregel catch or throw. Sie besagt, daß jede Ausnahme entweder behandelt oder weitergegeben werden muß. Wie man Ausnahmen behandelt, wurde anhand der `try`-`catch`-Anweisung in den vorherigen Abschnitten erklärt. Soll eine Ausnahme nicht behandelt, sondern weitergegeben werden, so kann dies einfach dadurch geschehen, daß eine geeignete `try`-`catch`-Anweisung nicht verwendet wird.

In der Regel gibt es dann jedoch zunächst einen Fehler beim Übersetzen des Programms, denn der Compiler erwartet, daß jede mögliche Ausnahme, die nicht behandelt, sondern weitergegeben wird, mit Hilfe der `throws`-Klausel zu deklarieren ist. Dazu wird an das Ende des Methodenkopfes das Schlüsselwort `throws` mit einer Liste aller Ausnahmen, die nicht behandelt werden sollen, angehängt:

    001 public void SqrtTable()
    002 throws ArithmeticException
    003 {
    004   double x = -1.0;
    005
    006   while (x <= 10.0) {
    007     System.out.println("sqrt("+x+")="+Math.sqrt(x));
    008     x += 1.0;
    009   }
    010 }

Listing 12.8: Verwendung der throws-Klausel

### 12.3.2 Weitergabe einer Exception

Tritt eine Ausnahme ein, sucht das Laufzeitsystem zunächst nach einer die Anweisung unmittelbar umgebenden `try`-`catch`-Anweisung, die diesen Fehler behandelt. Findet es eine solche nicht, wiederholt es die Suche sukzessive in allen umgebenden Blöcken. Ist auch das erfolglos, wird der Fehler an den Aufrufer der Methode weitergegeben. Dort beginnt die Suche nach einem Fehler-Handler von neuem, und der Fehler wird an die umgebenden Blöcke und schließlich an den Aufrufer weitergereicht. Enthält auch die Hauptmethode keinen Code, um den Fehler zu behandeln, bricht das Programm mit einer Fehlermeldung ab.

|  | Da alle Fehler, die nicht innerhalb einer Methode behandelt werden, dem Compiler mit Hilfe der `throws`-Klausel bekanntgemacht werden, kennt dieser zu jeder Methode die potentiellen Fehler, die von ihr verursacht werden können. Mit diesen Informationen kann der Compiler bei jedem Methodenaufruf sicherstellen, daß der Aufrufer seinerseits die catch-or-throw-Regel einhält. |  |
Hinweis

#### Die Klasse RuntimeException

Um den Aufwand durch explizites Fehler-Handling bei der Entwicklung von Java-Programmen nicht zu groß werden zu lassen, gibt es eine Ausnahme von der catch-or-throw-Regel. Direkt unterhalb der Klasse `Exception` gibt es die Klasse `RuntimeException`. Sie ist die Vaterklasse aller Laufzeitfehler, die zwar behandelt werden können, aber nicht müssen. Der Programmierer kann in diesem Fall selbst entscheiden, ob er den entsprechenden Fehler behandeln will oder nicht.

### 12.3.3 Auslösen von Ausnahmen

Wie schon erwähnt, sind Ausnahmeobjekte unter Java Instanzen bestimmter Klassen und können somit behandelt werden wie andere Objekte auch. Es ist also insbesondere möglich, ein Fehlerobjekt zu instanzieren oder eigene Fehlerklassen aus den vorhandenen abzuleiten.

Das Erzeugen eines Objekts aus einer Fehlerklasse gleicht dem Erzeugen eines Objekts aus einer beliebigen anderen Klasse. So legt die Anweisung `new ArithmeticException` ein neues Fehlerobjekt der Klasse `ArithmeticException` an, das einer Variablen des entsprechenden Typs zugewiesen werden kann.

Mit Hilfe der `throw`-Anweisung kann ein solches Objekt dazu verwendet werden, eine Ausnahme zu erzeugen. Die Syntax der `throw`-Anweisung ist:

    throw AusnahmeObjekt;

Die Behandlung dieser Fehler folgt den üblichen Regeln. Sie entspricht damit genau dem Fall, wenn anstelle der `throw`-Anweisung eine aufgerufene Methode denselben Fehler ausgelöst hätte: Zunächst wird in den umgebenden Blöcken nach einem Fehler-Handler gesucht. Falls das erfolglos ist, wird der Fehler an den Aufrufer weitergegeben.

|  |  |  | Die `throw`-Anweisung kann nicht nur dazu verwendet werden, neue Fehler auszulösen. Sie kann ebenfalls eingesetzt werden, um innerhalb der `catch`-Klausel einer `try`-`catch`-Anweisung das übergebene Fehlerobjekt erneut zu senden. In diesem Fall wird nicht noch einmal dieselbe `catch`-Klausel ausgeführt, sondern der Fehler wird gemäß den oben genannten Regeln an den umgebenden Block bzw. den Aufrufer weitergegeben. |  |
Tip

Auch selbstdefinierte Ausnahmen müssen sich an die catch-or-throw-Regel halten. Wird die Ausnahme nicht innerhalb derselben Methode behandelt, ist sie mit Hilfe der `throws`-Klausel im Methodenkopf zu deklarieren und weiter oben in der Aufrufkette zu behandeln.

Das folgende Beispiel definiert eine Funktion `isPrim`, die ermittelt, ob der übergebene Parameter eine Primzahl ist. Wird ein negativer Wert übergeben, verursacht die Methode eine Ausnahme des Typs `ArithmeticException`:

    001 public boolean isPrim(int n)
    002 throws ArithmeticException
    003 {
    004   if (n <= 0) {
    005     throw new ArithmeticException("isPrim: Parameter <= 0");
    006   }
    007   if (n == 1) {
    008     return false;
    009   }
    010   for (int i = 2; i <= n/2; ++i) {
    011     if (n % i == 0) {
    012       return false;
    013     }
    014   }
    015   return true;
    016 }

Listing 12.9: Auslösen einer Ausnahme

Die `throw`-Anweisung hat dabei den Charakter einer Sprunganweisung. Sie unterbricht das Programm an der aktuellen Stelle und verzweigt unmittelbar zu der umgebenden `catch`-Klausel. Gibt es eine solche nicht, wird der Fehler an den Aufrufer weitergegeben. Tritt der Fehler innerhalb einer `try`-`catch`-Anweisung mit einer `finally`-Klausel auf, wird diese noch vor der Weitergabe des Fehlers ausgeführt.

Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage, Addison Wesley, Version 3.0
<< | < | > | >> | API | © 1998-2002 Guido Krüger, http://www.javabuch.de