Java / Kontrollfluss, Exceptions, Thread - Fachbereich 4: HTW Berlin

Lecture Notes:
Java / Kontrollfluss, Exceptions, Thread
(Version 1.0, vom 30.04.2010, Autor: Prof. Schwotzer)
Java ist eine imperative Programmiersprache. Die einzelnen Statements eines Programmes
beschreiben, was zu tun ist. Die Statements werden nacheinander abgearbeitet. Man nennt
die Abfolge der Statements den Kontrollfluss (control flow). Der Kontrollfluss kann in
Schleifen und Verzweigungen gebracht werden. Dazu dienen die bereits aus C bekannten
Steuerelemente while, do-while, for und if-then-else. Diese Steuerelemente führen dazu, dass
der Steuerfluss Zeilen überspringt bzw. wieder in bereits abgearbeitete Statements
zurückspringt. Diese Elemente sind aus C hinlänglich bekannt und sollen hier nicht
wiederholt werden.
In Java spricht man auch davon, dass sich ein Asuführungsfaden (thread) durch das
Programm zieht. Der erste Ausführungsfaden beginnt mit dem ersten Statement der
gestarteten Main-Methode. Dieser Thread endet, wenn die Main-Methode beendet ist.
Visualisieren Sie sich das einmal an einem beliebigem Programm.
In Java kann man diesen Thread manipulieren, d.h. man kann ihn z.B. verzögern. Das
geschieht durch folgendes Kommando:
Thread.sleep(100);
Das obige Statement sorgt dafür, dass der Ausführungsthread 100 Millisekunden pausiert und
dann weiterläuft. Das Konzept des Thread mag auf Anhieb etwas eigenartig erscheinen.
Versuchen Sie es zu verinnerlichen, auch wenn es etwas schwer vorstellbar wirken sollte.
Konsequent ist es allemal:
Der Ausführungsfaden, der Kontrollfluss ist ein Ding. Es ist eine Entität, die eine wesentliche
Rolle in einem OO-System spielt. Konsequenterweise existiert ein Objekt, dass diese
Kontrollfluss repräsentiert. Und dieses Objekt kann man manipulieren. Lesen Sie sich einmal
weitere Methoden der Klasse Thread durch. Wie werden im Abschnitt „Multithreading“
darauf zurückkommen.
Ausnahmen
Wenn Sie eine Methode aufrufen, können grob drei Dinge passieren:
• Die Methode wird erfolgreich ausgeführt.
• Bei der Ausführung der Methode entstand ein Fehler. Das kann verschiedene
Ursachen haben
◦ Sie haben sich beim Aufruf nicht an den Contract gehalten, d.h. Es wurden falsche
Eingabeparameter übergeben,
◦ Während der Ausführung zeigte sich, trotz korrekter Eingabewerte, dass die
Methode nicht korrekt ausgeführt werden kann. Sie kann kein Ergebnis liefern.
• Während der Ausführung entstand ein Fehler, der nicht im Programm, sondern zur
Laufzeit des Programmes auftrat. Vielleicht ist die Datenbank gerade ausgefallen, auf

die Sie zugreifen. Das File, das just geöffnet wurde, lässt sich aus unklaren Gründen
nicht mehr schreiben, vielleicht ist der USB-Stick entfernt worden, …
In C werden diese Fälle lediglich durch den Rückgabeparameter entschieden. Ein guter
Aufruf in C sieht so aus:
int retval = f();
if(retval == ERROR) {
/* do something */
} else {
/* there is a result – do something useful */
}
Im Prinzip muss nach jedem Funktionsaufruf geprüft werden, ob die Funktion überhaupt
erfolgreich ausgeführt werden konnte. Das ist a) nertötend und b) unhandlich, weshalb viele
C-Programme darauf verzichten, was sie noch fehleranfälliger machen.
In Java hat man die unterschiedlichen Aspekte eines Rückgabewertes eine Methode getrennt,
indem das Konzept der Exception eingeführt wurde. Folgendes Codebeispiel soll die Nutzung
einer Exception illustrieren:
public void divide(int a, int b) throws Exception {
if(b == 0) {
Exception e = new Exception(“b darf nicht 0 sein“);
throw e;
}
}
return a / b;
Exception ist eine Klasse. Von ihr können Instanzen erzeugt werden. Das erfolgt mittels
new(). Ein Exception-Objekt repräsentiert einen konkreten Fehlerfall. In obigen Beispiel wird
ein Fehlerfall erkannt, wenn der zweiten Parameter 0 ist. In dem Fall wird ein Objekt erzeugt,
dass dieses Fehlerfall dokumentiert. Danach wird dieser Fehler mittels throw() geworfen. An
dieser Stelle wird der Kontrollfluss unterbrochen und an der Stelle fortgesetzt, an der die
Methode aufgerufen wurde.
Beachten Sie, dass Methoden deklarieren müssen, wenn das Werfen einer Exception möglich
ist. Das erfolgt mittels des Statement throws Exception.
Ein aufrufender Prozess kann auf zwei Arten mit möglichen Exceptions umgehen: Er kann sie
behandeln oder ebenfalls werfen. Beispiel:
...
int a = ?;
int b = ?;
int result;
try {
result = this.divide(a, b);
}
catch(Exception e) {
System.err.println(“etwas wirklich dummes passierte hier: “ + e.getMessage());
}
finally {
// was immer passierte, finally wird immer ausgeführt
}

Wenn mögliche Exceptions bearbeitet werden sollen, so müssen sie in einem try-catch-Block
stehen, siehe oben. Try bedeutet Versuchen. Es wird also versucht, Methoden auszuführen. In
dem Moment, wenn eine Methode mit einer Exception abgebrochen wird, wird auch der
Kontrollfluss innerhalb des try-Block abgebrochen.
Die Metapher bei Exception ist diese: Ein Exception-Objekt repräsentiert ein Problem, einen
Fehler, der zum Abbruch der Methode führte. Dieses Objekt wird aus der abgebrochenen
Methode herausgeworfen (throw). Wird eine Exception-Objekt nicht gefangen, so bricht es
auch die aufrufenden Methode ab und so weiter, bis es bei einer ersten main()-Methode
landet.
Exception-Objekte können aber gefangen werden (catch). Nun ist die Abbruchkaskade
unterbrochen. Die Exception wird behandelt. Die Art der Behandlung ist frei. Nicht selten,
wird das Problem lediglich dokumentiert, ein Default-Wert wird gesetzt und die Methode
läuft weiter. Manchmal wird das Problem dokumentiert und die Exception wird weiter
geworfen. Es steht Ihnen frei, mit Exceptions umzugehen.
Es gibt einen dritten Block, der finally-Block. Er wird eher selten genutzt. Dieser Code wird in
jedem Fall abgearbeitet, egal ob eine Exception geworfen wurde oder nicht.
Ein Beispiel im Semiar wird das Vorgehen vertiefen. Lesen Sie auch in einem Java-Buch das
Konzept der Exceptions nach.
Klassen von Exceptions
Es gibt eine Klassenhierarchie von Ausnahmen. Die Superklasse ist Throwable (Werbare).
Davon abgeleitet sind RuntimeException und Exception. Der Unterschied ist synaktischer
und semantischer Natur. RuntimeExceptions sind Fehler, die zur Laufzeit entstehen können
und auf deren Entstehung des Programm keinen Einfluss hat: Ausfall einer Datenbank,
Zusammenbruch des Netzwerkes, Fehler in externen Datenträgern sind Beispiele von
Laufzeitfehlern. Laufzeitfehler können jederzeit entstehen und jederzeit abgefangen werden.
RuntimeExceptions müssen aber nicht gefangen werden. Exception ist die Basisklasse aller
Ausnahmen, die im Kontext der Anwendung entstehen können. Sie zeigen Fehler an, die sich
aus der eigenen Anwendung, dem eigenen Programm, z.B. durch fehlerhalftes Verwenden von
Parameter etc. ergeben. Exceptions werden in der Methode deklariert und müssen gefangen
oder geworfen werden.
Einige Regeln
• Ein klassischer Anfängerfehler besteht in der Annahme, dass das Werfen von
Exceptions eine Art Unfähigkeit andeutet. Hier stimmt aber das Gegenteil. Profis
dokumentieren Fehler, Anfänger tendieren dazu, dass Fehler als etwas schlechtes zu
erkennen und meinen dass deren Existenz irgendwie und möglichst schnell behoben
werden muss. Das ist in realen Systemen in der Regel nicht möglich. Wie wollen Sie
bspw. in einer Methode arbeiten, die Zahlen addiert, wenn plötzlich eine Datenbank
ausfällt. Sehr häufig gibt es keine eindeutig und klaren Möglichkeiten, mit einem
Problem umzugehen. Das Werfen einer Exception ist daher der empfohlene Weg,
Probleme zu dokumentieren und zu publizieren. Arbeiten Sie professionell und
werfen Sie Exceptions!
• Es ist guter Stil, wenn die try-Blöcke klein sind. Der Code mag eigenartig aussehen,

wenn nur wenige Methoden geklammert sind und ständig Exceptions abgefangen
werden. Ein Anfängerfehler besteht darin, lange try-Blöcke zu schreiben, die aber
nicht zusammen gehören. Statement gehören dann in einen try-Block, wenn nach
dem Abbruch der Abarbeitung keine Statement, aber auch wirklich kein weiteres
Statement sinnvoll ausgeführt werden kann. Dann kann der gesamte Block
unterbrochen werden und die Ausnahmebehandlung kann starten.
Wenn aber die Abarbeitung mittels des Setzens eine Defaults oder ähnlichen
weitergehen kann, so ist der try-Block zu trennen. Das werden wir üben.
• Definieren Sie eigene Exception-Klassen. Wenn Sie eine eigene Anwendung haben, so
definieren Sie sich eine eigenen Exception-Klasse
class MyException extends Exception {}
Auf diese Weise können Sie überall erkennen, ob die Exception aus Ihrem System
kommt oder von anderen Stellen. Wenn Sie unterschiedliche Klassen von Ausnahmen
haben, so definieren Sie mehrere Klassen, z.B. WrongParameterMyException,
NoUserReplyMyException, die alle von Ihrer Basisklasse ableiten. Dadurch wird
solcher Code möglich:
...
try {...}
catch(WrongParameterMyException wpme) { ... }
catch(NoUserReplyMyException nurme) { ... }
catch(MyException me) { ... }
catch(Exception e) { ... }
Durch so ein Vorgehen, können Sie zunächst sehr spezielle und dann immer
konkretere Ausnahmen auffangen. Vieles catch-Blöcke zeugen in der Regel von einem
professionellen Vorgehen. Hier wurden mögliche Fehler und deren Behandlung
ausführlich beachtet.
• Fangen Sie nur RuntimeExceptions, wenn Sie genau wissen, was Sie dagegen tun
können. Es ist manchmal deutlich besser, wenn ein Programm kontrolliert terminiert,
als wenn es irgendwie weiterläuft. Beispiel: Wenn das Netzwerk zusammenbricht, so
können Sie in Ihrem Java-Programm durchaus Exceptions dazu fangen und das
Programm am laufen halten. Es wird nur keinen sinnvollen Beitrag mehr liefern.
Beenden Sie es besser. Dokumentieren Sie ggf. den Fehler, aber machen Sie Schluss.