Exception - megloff.ch

Java
Programmierung mit
Exceptions
> Fehlerbehandlung
in Java
Mark Egloff 2006
1
Java
Programmierung mit
Lernziel Heute Abend
>
Sie lernen die Bedeutung von Exceptions kennen
>
Sie wissen wie Laufzeitfehler in Java erzeugt und gehandhabt
werden
>
Sie können gezielt eigene Fehlerbehandlungen
implementieren
Mark Egloff 2006
2
Java
Programmierung mit
Exceptions
„Wir sind in Sicherheit! Er kann uns nicht erreichen! – Sicher? –
Ganz sicher! Bären haben Angst vor Treibsand!“
Häger, Dik Browne
Mark Egloff 2006
3
Java
Programmierung mit
Exceptions
Was ist eine „Exception“ ?
>
Exceptions bedeutet übersetzt Laufzeitfehler oder Ausnahmesituation.
Darunter werden Fehler verstanden, welche erst bei der Ausführung des
Programms auftreten
>
Viele Laufzeitfehler lassen sich auf Programmierfehler zurückführen z.B.
NullPointerException, die aber unter Umständen nur bei seltenen
Situationen stattfinden. Die Gründe können manchmal sehr komplex sein
>
Es gibt auch Laufzeitfehler die nicht unbedingt auf „schlechte“ Programmierung zurückzuführen sind z.B. Datei auf CD-ROM abspeichern
 Der Benützer wählte das falsche Laufwerk.
>
All diese Laufzeitfehler müssen von unseren Programmen erkannt und
behandelt werden, ansonsten würde das Programm einfach „abstürzen“
>
Java bietet eine elegante Methode, um mit Fehlern flexibel umzugehen
Mark Egloff 2006
4
Java
Programmierung mit
Excpetions
Unterschiede Compiler- Fehler vs. Laufzeitfehler
>
Fehler können anhand des Zeitpunkts ihres Auftretens unterschieden
werden: Fehler treten schon bei der Übersetzung oder erst zur Laufzeit auf.
>
Sicherlich sind Fehler, die der Compiler entdeckt, die angenehmeren. Man
kann sie analysieren und den Code entsprechend anpassen.
>
Im ungünstigeren Fall treten Laufzeitfehler erst beim Anwender – dem
Kunden – auf und beenden das Programm ohne geeignete Behandlung,
lassen es »abstürzen«.
>
Die Behandlung der Laufzeitfehler macht bei interaktiven Programmen
häufig den Hauptteil des Codes aus. Die produktiven Programmteile sind
mit unzähligen Kontrollanweisungen durchsetzt, die auf Umweltsituationen
reagieren müssen  Konfigurationsmanagement
>
Laufzeitfehler werden daher häufig ignoriert!  da Aufwendig
Mark Egloff 2006

5
Java
Programmierung mit
Excpetions
Typische Laufzeitfehler
>
Hier sind einige Laufzeitfehler aufgelistet, die wohl am häufigsten
Programme zum Absturz bringen:
>
NullPointerException: Zugriff über eine Referenz auf eine Objekteigenschaft.
Die Referenz zeigt aber auf kein Objekt sondern ist NULL
>
ArrayIndexOutOfBoundsException: Zugriff auf Arrayfelder ausserhalb der
Arraygrenzen
>
IllegalArgumentException: Ungültiger Parameterwert wurde übergeben
>
ArithmeticException: Division durch 0
Mark Egloff 2006
6
Java
Programmierung mit
Excpetions
Beispiel eines „unerwarteten“ Laufzeitfehler (1/3)
>
In den abgegeben Dateien Finden Sie eine Applikation, die „manchmal“
einen Fehler auslöst. Die Applikation ist schon bekannt der DES
Verschlüsseler von Lektion 06
>
Öffnen Sie nun das vorbereitete Projekt in Eclipse:
1. Lektion11.zip Datei vom Email entpacken und in einen Ordner ablegen
2. Eclipse starten
3. Projekt importieren mittels Menu „File > Import“
4. Aus dem Import Wizard „General > Existing Project into Workspace“ wählen
5. Den Ordner „Lektion 11\Example“ aus der entpackten Zip Datei wählen
>
Starten Sie „RunVerschluesselung“. Die Applikation liest ein String ein und
verschlüsselt es mit dem „DES“ Algorithmus. Experimentieren Sie mit
unterschiedlichen Text längen 5-10 Zeichen. Was Stellen Sie fest?
Mark Egloff 2006
7
Java
Programmierung mit
Excpetions
Beispiel eines „unerwarteten“ Laufzeitfehler (2/3)
>
Die Applikation löst bei einer bestimmten String Längen (x % 8 == 0) einen
Fehler aus und bricht das Programm aus. Das wäre ärgerlich wäre es beim
Testen nicht aufgefallen
Ablauf des Programmes „RunVerschluesselung“
Bitte geben sie den Text für eine Verschlüsselung ein:
Java ist einfach
DES verschlüsselung:16
’d}¾Öíb=«^fŸåbHˆ?¥J•
Exception in thread "main" java.lang.RuntimeException:
javax.crypto.BadPaddingException:
Given final block not properly padded
at DESVerschluessler.decrypt(DESVerschluessler.java:61)
at RunVerschluesselung.main(RunVerschluesselung.java:20)
Mark Egloff 2006
8
Java
Programmierung mit
Excpetions
Beispiel eines „unerwarteten“ Laufzeitfehler (3/3)
>
Noch ärgerlicher, wir „haben“ den SourceCode nicht zur Verfügung dort wo
der Fehler auftritt (DESVerschluessler.java:61). Somit bleibt uns nur noch
die Möglichkeit übrig den Fehler abzufangen und zu behandeln.
>
Hierzu verwenden wir die „try/catch“ Möglichkeit. Hängen Sie unten an den
bestehenden „catch“ Block in „main()“ folgenden Code an und
wiederholen Sie die Fehlerauslösung, beobachten Sie nun das Resultat.
catch(RuntimeException rt){
System.out.println("unerwarterter Fehler:" + rt);
}
>
Der Fehler tritt nun immer noch auf, aber wir haben nun die Möglichkeit an
dieser Stelle zu reagieren z.B. eine Behandlung oder gar Wiederholung
durchzuführen.
Mark Egloff 2006
9
Java
Programmierung mit
Exceptions
Früheres Konzept der Fehlerbehandlungen
>
Viele ältere Sprachen z.B. VB, C, Perl besitzen kein spezielles Konzept
für die Fehlerbehandlung
>
Es wurde oft der Rückgabewert einer Methode verwendet, um einen
Fehlschlag anzuzeigen. Der Fehlercode war häufig einfach –1, aber auch
NULL oder 0. Ein Standard gab es nicht
>
Ein Folge-Problem stellte dann Wartbarkeit des Programms dar. Der
Programmfluss wird durch Abfragen der Funktionsergebnisse
unangenehm unterbrochen. Häufig entstehen mit den Fehlerabfragen
kaskadierte if-Abfragen, die den Quellcode schwer lesbar machen. Die
Fehlerbehandlung erfolgte dann nicht zentral sondern war an mehreren
Stellen im Code verteilt.
>
Ein neues Konzept musste deshalb dringend her
Mark Egloff 2006
10
Java
Programmierung mit
Exceptions
Früheres Konzept der Fehlerbehandlungen
z.B.: Problem negativer Radius bei Klasse „Kreis“
Kreis k = new Kreis(-3.5f);
System.out.println( k.berechneUmfang() );  negativ
z.B. Methode mit Rückgabewert um Fehler zu signalisieren
public float berechneUmfang() {
if (this.radius < 0) return -1;
else return this.radius * 2 * PI;
}
z.B. Fehlerbehandlung anhand des Rückgabewertes
if (k.berechneUmfang() == -1 )
System.err.println("Fehler aufgetreten!");
Mark Egloff 2006
11
Java
Programmierung mit
Exceptions
Das neue Konzept: „Try“ und „Catch“
>
Das neue Konzept heisst „Try“ und „Catch“ und es wurde in die neueren
Sprachen (z.B. C++, Java, C#, Javascript, PHP) gerade als
grundlegender Syntax eingebettet
>
Bei der Verwendung dieses Konzeptes wird der Programmfluss nicht
unterbrochen, sondern ein besonders ausgezeichnetes Programmstück
wird bezüglich auftretender Fehler überwacht und gegebenenfalls
spezieller Code zur Behandlung solcher Fehler aufgerufen.
Mark Egloff 2006
12
Java
Programmierung mit
Exceptions
Das neue Konzept: „Try“ und „Catch“
>
Ein überwachter Programmbereich (Block) wird mit dem Schlüsselwort
„try“ eingeleitet und mit „catch“ beendet. Hinter „catch“ folgt der
Programmblock, der beim Auftreten eines Fehlers ausgeführt wird, um
den Fehler abzufangen oder zu behandeln.
>
Anstelle eines Fehlercodes wird im Falle eines Fehlers ein
Exceptionobjekt erzeugt, dass alle Angaben des Fehlers beinhaltet.
Dieses wird an die Behandlungsroutine weitergeleitet.
>
Um Fehlerbehandlungen zu erzwingen, überwacht der Compiler, dass
alle möglichen, auftretenden Fehler mittels „try“ und „catch“ in einer
Applikation behandelt werden. Wird dies nicht gemacht, treten
entsprechende Compilerfehler auf. Somit müssen Programmierer eine
Behandlung implementieren
Mark Egloff 2006
13
Java
Programmierung mit
Exceptions
Das neue Konzept: „Try“ und „Catch“
Beispiel 1: Einfache Methode mit „try“ und „catch“ Block
public void setRadius(float radius) {
try {
if ( radius < 0) throw new Exception("radius < 0!");
else this.radius = radius;
}
catch( Exception ex){
Fehlerauslösung
System.err.println(ex);
}
}
Fehlerbehandlung
Mark Egloff 2006
14
Java
Programmierung mit
Excpetions
Mark Egloff 2006
15
Java
Programmierung mit
Exceptions
Das neue Konzept: „Try“ und „Catch“
Der Programmfluss bei einer einfachen Exception
try
{
Try Block
Foo f = x.doRiskyThing()
Fehler
}
catch(Exception ex)
{
y.handleError(ex);
Catch Block
}
Ablauf im
Normalfall
Ablauf im
Fehlerfall
Mark Egloff 2006
16
Java
Programmierung mit
Exceptions
Syntax Regeln für „Try“
try { ... }
>
Mit „try“ leiten wir einen Block ein indem mögliche Exceptions
auftreten können
>
Nach dem Schlüsselwort „try“ folgt immer ein Block mit „{}“ Klammern
>
Nach dem „try“- Block muss mindestens ein „catch“- oder ein
„finally“- Block folgen.
Mark Egloff 2006
17
Java
Programmierung mit
Exceptions
Syntax Regeln für „Catch“
catch(Exception ex) { ... }
>
Mit „catch“ leiten wir einen Block ein indem geworfene Exceptions
aufgefangen und behandelt werden können
>
Nach dem Schlüsselwort „catch“ folgt eine Parameterübergabe. Dort
wird ein „Exception“ - Objekt an den Behandlungsblock übergeben. Es
muss der Typ und Namen des Parameters angegeben werden. Es wird
nur ein Parameter unterstützt und er muss vom Typ „Throwable“ sein
>
Nach der Parameterübergabe folgt der Implementationsblock mit „{}“
Klammern
>
Es dürfen mehrere „catch“-Blöcke nach einem „try“-Block folgen,
jedoch muss jeder „catch“ Block einen anderen Parametertyp
aufweisen, ähnliche Regel wie beim Überladen der Methoden.
Mark Egloff 2006
18
Java
Programmierung mit
Exceptions
Wie weiss ich wann welche Fehler auftreten können?
Beispiel 2: Ermittlung und implementation einer Fehlerbenhandlung
>
Wir wollen eine Datei mit Hilfe der Klasse
„java.io.RandomAccessFile“ zeilenweise auslesen. Hierzu
betrachten wir kurz das JavaDoc der Klasse
>
Aus der API-Dokumentation geht hervor, dass der Konstruktor von
„RandomAccessFile“ eine „FileNotFound“ Exception-Ausnahme
auslösen kann.
>
Mithilfe der Funktion „readLine()“ lesen wir so lange Zeilen ein, bis
die Datei ausgeschöpft ist. Die Methode „readLine()“ kann eine
„IOException“ auslösen.
>
Wir müssen diese Exceptions behandeln und setzen daher die
Problemzonen in einen try- und catch-Block.
Mark Egloff 2006
19
Java
Programmierung mit
Exceptions
Wie weiss ich wann welche Fehler auftreten können?
Beispiel 2: Ermittlung und implementation einer Fehlerbenhandlung
Auschnitt aus dem JavaDoc der Klasse „java.io.RandomAccessFile“
Mark Egloff 2006
20
Java
Programmierung mit
Exceptions
Wie weiss ich wann welche Fehler auftreten können?
Beispiel 2: Ermittlung und implementation einer Fehlerbenhandlung
import java.io.*;
public class ReadFileWithRAF {
public static void main( String[] args ) {
try {
RandomAccessFile f;
f = new RandomAccessFile( "EastOfJava.txt", "r" );
for ( String line; (line=f.readLine()) != null; )
System.out.println( line );
}
catch ( FileNotFoundException e ) {
System.err.println( "Datei gibt’s nicht!" );
}
catch ( IOException e ){
System.err.println( "Schreib- Leseprobleme!" );
}
}
}
Mark Egloff 2006
21
Java
Programmierung mit
Exceptions
Das neue Konzept: „Try“ und „Catch“
Wiederholung kritischer Bereiche
>
Es gibt in Java bisher keine Möglichkeit bei Exceptions, an den Punkt
zurückzukehren, der den Fehler ausgelöst hat. Das ist aber oft
erwünscht, z.B. wenn eine fehlerhafte Eingabe zu wiederholen ist.
>
Um dieses Problem zu lösen muss die Behandlung des Fehlers
innerhalb der Wiederholung bzw. Schleife erfolgen.
>
Hierbei ist natürlich Vorsicht geboten, da dies schnell zu
Endlosschleifen führen kann. Sofern möglich, sollten solche Konstrukte
vermieden werden
Mark Egloff 2006
22
Java
Programmierung mit
Exceptions
Das neue Konzept: „Try“ und „Catch“
Wiederholung kritischer Bereiche
z.B. Wiederholung einer Eingabe
int number = 0;
while ( true ) {
try {
System.out.print( "Bitte Zahl eingeben" );
number = Integer.parseInt( s );
break;
}
catch ( NumberFormatException e ) {
System.out.println( "Das war keine Zahl!" );
}
}
Mark Egloff 2006
23
Java
Programmierung mit
Exceptions
Fehler weiterleiten, die Anweisung „throws“
Es ist nicht immer sinnvoll jeden Fehler gerade an der Stelle zu
behandeln wo er aufgetreten ist. Dies würde in eine Unmenge von
„try“ und „catch“ Blöcken enden, welches die Wartbarkeit des Codes
erschweren würde.
>
Es gibt daher die Möglichkeit anstelle den Fehler direkt mit „catch“
abzufangen diesen einfach an die nächst höhere Methode im Stack
weiterzureichen. Dies erlaubt es später die Fehlerbehandlungen zu
zentralisieren und somit zu vereinfachen.
StackTrace
>
MyApp.main(args)
MyApp.eingabe()
Kreis.setRadius(r)
Mark Egloff 2006
Fehler
24
Java
Programmierung mit
Exceptions
Fehler weiterleiten, die Anweisung „throws“
>
Diese Weiterleitung wird mit einen Anweisung „throws“ erreicht. Diese
muss bei der Methodendeklaration nach der Parameterübergabe
angegeben werden. Falls mehrere Arten von Exceptions ausgelöst
werden, müssen diese einfach mittels Kommas getrennt aufgelistet
werden
z.B. Weiterleitung einer Exception
class Kreis {
...
public void setRadius(float radius) throws Exception {
if ( radius < 0) throw new Exception("radius < 0!");
else this.radius = radius;
}
}
Mark Egloff 2006
25
Java
Programmierung mit
Exceptions
Fehler weiterleiten, die Anweisung „throws“
>
Mittels der Weiterleitung „bubbelt“ der Fehler entlang nach oben und
kann dann irgendwann abgefangen werden
z.B. Weiterleitung und Abfangen der Exception in „main()“
class MyApp {
public static void main(String args[]) {
try {
Kreis k = eingabe(); Fehler
}
catch(Exception ex) {
System.err.println(ex);
}
}
}
Mark Egloff 2006
26
Java
Programmierung mit
Exceptions
Fehler weiterleiten, die Anweisung „throws“
>
Ist die Fehlerbehandlung in einer Applikation ganz „egal“, können wir
alle Fehler an die JVM weiterleiten, die dann das Programm im
Fehlerfall abbricht.
>
Hierbei muss lediglich die „throws“ Anweisung bei der
Methodendeklaration von „main()“ angewendet werden
z.B. Weiterleitung der Exception an die JVM
class MyApp {
public static void main(String args[]) throws Exception
{
...
}
}
Mark Egloff 2006
27
Java
Programmierung mit
Exceptions
Abschliessende Arbeiten mit „finally“
>
Es gibt Fälle wobei immer abschliessende Arbeiten getätigt werden
müssen. Diese sind unabhängig von den zuvor aufgetretenen Fehlern
z.B. die Freigabe von Ressourcen  schliessen von Dateien. Diese
müssen immer ausgeführt werden
>
Hierzu wurde im Konzept ein zusätzlicher Block vorgesehen Nach
einem (oder mehreren) catch kann deshalb optional ein „finally“Block folgen.
>
Die Anweisungen im „finally“-Block werden immer ausgeführt, auch
wenn in „try“ und „catch“ ein „return“, „break“ oder „continue“
steht.
 Das bedeutet, der „finally“ Block wird in jedem Fall
ausgeführt.
Mark Egloff 2006
28
Java
Programmierung mit
Exceptions
Abschliessende Arbeiten mit „finally“
Der Programmfluss bei „finally“
Try Block
try
{
Foo f = x.doRiskyThing()
}
Catch Block
catch(Exception ex)
{...}
Finally Block
finally
{
closeResources();
}
Mark Egloff 2006
Fehler
Ablauf im
Normalfall
Ablauf im
Fehlerfall
29
Java
Programmierung mit
Exceptions
Abschliessende Arbeiten mit „finally“
Beispiel: Freigabe der Ressource im „finally“ Block
import java.io.*;
public class ReadFileWithRAF {
public static void main( String[] args ) {
try {
RandomAccessFile f;
f = new RandomAccessFile( "EastOfJava.txt", "r" );
for ( String line; (line=f.readLine()) != null; )
System.out.println( line );
}
catch ( FileNotFoundException e ) {...}
catch ( IOException e ){...}
Dummerweise kann „close()“ ebenfalls
finally {
eine Exception auslösen
if ( f != null )
try { f.close(); }
catch ( IOException e ) { e.printStackTrace(); }
}
}
}
Mark Egloff 2006
30
Java
Programmierung mit
Exceptions
Syntax Regeln für „finally“
finally { ... }
>
Mit „finally“ leiten wir einen Block ein, der in jedem Fall abgearbeitet
wird. Er ist daher ideal um abschliessende Arbeiten zu tätigen
>
Der „finally“ Block ist im Zusammenhang mit „try“ und „catch“
optional. Jedoch kann „finally“ nicht alleine für sich stehen. Er muss
immer nach einem „try“ Block folgen.
>
Nach dem Schlüsselwort „finally“ folgt der Implementationsblock mit
„{}“ Klammern
>
Es darf pro „try“ Block nur ein „finally“ Block implementiert werden
Mark Egloff 2006
31
Java
Programmierung mit
Exceptions
Abschliessende Arbeiten mit „finally“
Beispiel: „try“ und „finally“ ohne „catch“ Block
public class NoCatchBecauseOfFinallyBlock
{
static void buh() {
try {
throw new ArithmeticException(
"Keine Lust zu rechnen" );
}
finally {
System.out.println( "Mach noch was zum Schluss!" )
}
}
public static void main( String[] args ) {
buh();
}
}
Mark Egloff 2006
32
Java
Programmierung mit
Exceptions
Abschliessende Arbeiten mit „finally“
Beispiel: Keine Exceptionweiterleitung
public class NoExceptionBecauseOfFinallyReturn
{
static void buh() {
try {
throw new ArithmeticException(
"Keine Lust zu rechnen" );
}
finally {
Dummerweise wird die Methode vorher verlassen
return;
bevor die Weiterleitung der Exception erfolgen
}
kann!
}
public static void main( String[] args ) {
buh();
}
}
Mark Egloff 2006
33
Java
Programmierung mit
Exceptions
Exceptions sind Objekte
Erzeugung und Handhabung von Exceptions
>
Tritt ein Fehler auf, so wird ein so genanntes Exception-Objekt erzeugt.
Diese wird dann an den nächsten, entsprechenden „catch“ Block als
Parameter übergeben.
>
Dieses Objekt ist ein ganz normales Java Objekt und stammt von einer
Klasse „java.lang.Throwable“ ab (Basisklasse aller Exceptions).
Es werden somit alle nötigen Angaben des Fehlers in ein Objekt
gepackt und stehen dann bei der Behandlung zur Verfügung
>
Eine Exception wird zuerst mittels dem „new“ Operator und dem
Konstruktoraufruf der Klasse instanziert. Danach wird es mit der
Anweisung „throw“ geworfen bzw. als Fehler ausgelöst
Mark Egloff 2006
34
Java
Programmierung mit
Exceptions
Exceptions sind Objekte
Erzeugung und Handhabung von Exceptions
z.B. Erstellung und Auslösung einer Exception
public void setRadius(float radius) {
if ( radius < 0)
throw new IllegalArgumentException("radius < 0!");
}
1. Exception-Klasse muss vom Typ „Throwable“ abgeleitet sein
2. Exception-Objekt instanzieren
3. Exception-Objekt mittels „throw“ werfen
Mark Egloff 2006
35
Java
Programmierung mit
Exceptions
Exceptions sind Objekte
Erzeugung und Handhabung von Exceptions
>
Wichtige Eigenschaften eines Exception-Objektes sind:
>
„getClass()“: die Klasse selber gibt den Typ der Exception an
>
„getMessage()“:Fehlermeldung (falls nötig in mehreren Sprachen)
>
„printStackTrace()“: Ausgabe des Stacktrace (Angabe in welcher Klasse,
Methode und bei welcher Linie des SourceCodes der Fehler ausgelöst wurde)
>
„getCause()“: Ursprünglicher Fehler (falls dies nur ein Folgefehler bzw. eine
Weiterleitung war)
z.B. Zugriff auf Eigenschaften des Exception-Objektes bei der Behandlung
catch(IllegalArgumentException ex){
System.err.println( ex.getMessage() );
ex.printStackTrace();
}
Mark Egloff 2006
36
Java
Programmierung mit
Exceptions
Arten und Hierarchie von Exceptions
>
Das Java API besitzt eine grosse Menge an unterschiedlichen ExceptionKlassen ca.750 Klassen.
>
Bei einer solchen grossen Menge an verschiedenartiger Fehler wäre der
Programmierer überfordert für jede einzelne mögliche Exception eine
entsprechende Behandlungsroutine zu implementieren
>
Um diese Handhabung zu vereinfachen wurde die Hierarchie bei der
Behandlung der Exceptions berücksichtigt. Diese erlaubt es, Fehler
generisch handzuhaben.
>
Als Grundlage für dieses Hierarchie-Konzept wird die Vererbung und das
Überladen von Methoden bzw. von „catch“ Blöcken verwendet
Mark Egloff 2006
37
Java
Programmierung mit
Exceptions
Arten und Hierarchie von Exceptions
>
Eine Exception ist ein Objekt, welches direkt oder indirekt von
„java.lang.Throwable“ abgeleitet ist.
>
Von dort aus verzweigt sich die Vererbungshierarchie der Exception-Arten
nach „java.lang.Exception“ und „java.lang.Error“.
>
Die Klassen, die aus „Error“ hervorgehen, müssen nicht weiterverfolgt
werden. Es handelt sich hierbei um Fehler, die so schwerwiegend sind,
dass sie zur Beendigung des Programms führen und vom Programmierer
nicht weiter beachtet werden müssen.
Mark Egloff 2006
38
Java
Programmierung mit
Exceptions
Arten und Hierarchie von Exceptions
Mark Egloff 2006
39
Java
Programmierung mit
Exceptions
Arten und Hierarchie von Exceptions
Mark Egloff 2006
40
Java
Programmierung mit
Exceptions
Arten und Hierarchie von Exceptions
>
Alle Exceptions können vom Typ der Basisklasse und somit auch als
„Throwable“ gehandhabt werden.
z.B. Austauschbarkeit bei Objekten, dies gilt auch bei Exceptions
Throwable t = new FileNotFoundException();
Exception e = new FileNotFoundException();
IOException ioe =
new FileNotFoundException();
FilenotFoundException fnfe =
new FileNotFoundException();
Throwable
Exception
IOException
FileNotFoundException
Mark Egloff 2006
41
Java
Programmierung mit
Exceptions
Arten und Hierarchie von Exceptions
>
Dieses Prinzip erlaubt uns zu entscheiden nach welcher Priorität wir die
Exceptions handhaben möchten. z.B. können wir gewisse Exceptions
generisch oder andere explizit abhandeln
>
Wenn zum Beispiel eine „FileNotFoundException“ auftritt, dann ist
diese Klasse von „IOException“ abgeleitet. Wenn wir alle
„IOException“ auffangen, behandeln wir damit auch gleichzeitig die
„FileNotFoundException“ mit
>
Besitzt ein „try“ Block mehrere „catch“ Blöcke so wird jeweils der
„catch“ Block genommen bei dem der Parameterdatentyp mit dem
jeweiligen Exception-Objekt am nächsten verwand ist
Mark Egloff 2006
42
Java
Programmierung mit
Exceptions
Arten und Hierarchie von Exceptions
Beispiel: „FileNotFoundException“ als „IOException“ handhaben
RandomAccessFile f = null;
try {
f = new RandomAccessFile( "d:/file.txt, "r" );
Fehler
for ( String line; (line = f.readLine()) != null; )
System.out.println( line );
}
catch ( IOException e ) {
System.err.println( "Ein/Ausgabe-Probleme." );
Throwable
}
Exception
IOException
FileNotFoundException
Mark Egloff 2006
43
Java
Programmierung mit
Exceptions
Arten und Hierarchie von Exceptions
Beispiel: „IOException“ als „Exception“ handhaben
RandomAccessFile f = null;
try {
f = new RandomAccessFile( "d:/file.txt, "r" );
for ( String line; (line = f.readLine()) != null; )
System.out.println( line );
}
Fehler
catch ( FileNotFoundException e ) {...}
catch ( Exception e ) {...}
Throwable
catch ( Throwable t ) {...}
Exception
IOException
FileNotFoundException
Mark Egloff 2006
44
Java
Programmierung mit
Exceptions
Arten und Hirarchie von Exceptions
>
Um alle Arten von Fehlern abzufangen können die Exceptions jeweils
weitergeleitet werden und in „main()“ als Typ „Throwable“ behandelt
werden
z.B. Generische Handhabung von Exceptions
class MyApp {
public static void main(String args[]) {
try {
...
}
catch( Throwable t ) {
System.err.println(t);
}
}
}
Mark Egloff 2006
45
Java
Programmierung mit
Exceptions
Arten und Hierarchie von Exceptions
RuntimeExceptions
>
Einige Fehlerarten können potenziell an vielen Programmstellen auftreten,
etwa eine Division durch 0 oder ungültige Indexwerte beim Zugriff auf
Array-Elemente.
>
Treten solche Fehler beim Programmlauf auf, liegt in der Regel ein
Denkfehler des Programmierers vor, und das Programm sollte
normalerweise nicht versuchen, die ausgelöste Ausnahme aufzufangen
und zu behandeln.
>
Daher wurde die Unterklasse „RuntimeException“ eingeführt, die Fehler
beschreibt, die vom Programmierer behandelt werden können, aber nicht
müssen.
Mark Egloff 2006
46
Java
Programmierung mit
Exceptions
Arten und Hierarchie von Exceptions
RuntimeExceptions
Mark Egloff 2006
47
Java
Programmierung mit
Exceptions
Arten und Hierarchie von Exceptions
Harte Fehler: Errors
>
Fehler, die von der Klasse „java.lang.Error“ abgeleitet sind, stellen
Fehler dar, die mit der JVM in Verbindung stehen.
>
Beispiele für konkrete Error-Klassen sind AnnotationFormatError,
AssertionError, AWTError, CoderMalfunctionError,
FactoryConfigurationError, LinkageError, ThreadDeath,
TransformerFactoryConfigurationError, VirtualMachineError (mit den
Unterklassen InternalError, OutOfMemoryError, StackOver-flowError,
UnknownError).
>
Da solche Fehler „abnormales“ Verhalten anzeigen, müssen sie auch nicht
mit einem „try/catch“-Block aufgefangen werden oder mit „throws“
weiter nach oben geleitet werden.
Mark Egloff 2006
48
Java
Programmierung mit
Exceptions
Arten und Hierarchie von Exceptions
Unchecked Exceptions
>
„RunTimeExceptions“ und „Error“ werden nicht vom Compiler überwacht.
Man spricht auch in solchen Fällen von „Unchecked Exceptions“
Mark Egloff 2006
49
Java
Programmierung mit
Exceptions
Eigene Exception Klassen definieren
>
Bevor man eigene Exceptionklassen entwirft, sollte man sich erst
überlegen was für eine Art von Fehler es ist und wie er behandelt werden
sollte. Hierbei sind folgende Denkschritte hilfreich:
1.
2.
Beschreibt wirklich keine bestehende Exception Klasse des Java API diese
Ausnahme?  JavaDoc ansehen, mit Google nach Hinweisen suchen
>
Ja
>
Nein  Eigene Exceptionklasse implementieren
 Bestehende Klassen verwenden oder von Ihr ableiten
Suchen der geeigneten Basis-ExceptionKlasse: Muss der Programmierer
diese zwingend behandeln?
>
Ja
>
Nein  „Error“ oder „RuntimeException“ als Basisklasse nehmen
 „Throwable“ oder „Exception“ als Basisklasse nehmen
Mark Egloff 2006
50
Java
Programmierung mit
Exceptions
Eigene Exception Klassen definieren
>
Eigene Exceptions sind direkte oder indirekte Unterklassen von Exception.
Sie implementieren oft zwei Konstruktoren: einen Standard-Konstruktor
und einen mit einem String parametrisierten Konstruktor.
z.B. Eigene Exception-Klasse implementieren
public class IllegalSchokoColorException
extends IllegalArgumentException {
public IllegalSchokoColorException() {
super();
}
public IllegalSchokoColorException( String s ) {
super( s );
}
}
Mark Egloff 2006
51
Java
Programmierung mit
Exceptions
Eigene Exception Klassen definieren
z.B. Eigene Exception-Klasse werfen
class Schokolade {
String f;
public Schokolade(String f) {
this.f = f;
}
public test() throws IllegalSchokoColorException {
if (...)
throw new IllegalSchokoColorException(
"Diese Schokoladen-Farbe gibt es nicht:" + f);
}
Mark Egloff 2006
52
Java
Programmierung mit
Exceptions
Eigene Exception Klassen definieren
z.B. Eigene Exception-Klasse werfen
class MyApp {
public static void main( String[] args ){
try {
Schokolade ws = new Schokolade( "pink" );
ws.test();
}
catch( IllegalSchokoColorException isce ) {
System.err.println( "Falsche Schokoladen-Farbe" );
isce.printStackTrace();
}
}
}
Mark Egloff 2006
53
Java
Programmierung mit
Exceptions
Eigene Exception Klassen definieren
z.B. Eigene Exception-Klasse werfen - Ausgabe
Falsche Schokoladen-Farbe:
IllegalSchokoColorException: Diese Schokoladen-Farbe gibt
es nicht: pink
at Schokolade.<init>(Schokolade.java:11)
Mark Egloff 2006
54
Java
Programmierung mit
Exceptions
Geschachtelte Exceptions
>
In Java lassen sich Exceptions ineinander verschachteln. Dies ist nützlich
um z.B. Folgefehler zu kreieren
>
Ein Anwendungsfall wäre hierzu eine Transaktion. Ist ein Teil der Kette
fehlerhaft, so ist der ganze Teil nicht ausführbar.
>
Eine geschachtelte Exception (engl. nested exception) speichert einen
Verweis auf eine weitere Ausnahme. Wenn ein Exception-Objekt
aufgebaut wird, lässt sich der Grund (engl. cause) als Argument im
Konstruktor der Throwable-Klasse übergeben. Die Ausnahme-Basisklasse
bietet dafür zwei Konstruktoren:
>
Throwable( Throwable cause )
>
Throwable( String message, Throwable cause )
Mark Egloff 2006
55
Java
Programmierung mit
Exceptions
Geschachtelte Exceptions
z.B. Eine geschachtelte Exception erzeugen und behandeln
public static void main( String[] args ){
try {
throw new Exception( new Exception("inner"));
}
catch( Exception ex ) {
Throwable cause ex.getCause();
cause.printStackTrace();
}
}
Bei generischen Fehlerbehandlungen muss deshalb speziell darauf
geachtet werden, dass auch die „cause“ Exception ausgewertet
wird
Mark Egloff 2006
56
Java
Programmierung mit
Exceptions
Tipps
>
Bestehender Programmfluss analysieren und verstehen, so dass
Exceptions gezielt eingesetzt werden können
>
Nie eine Exception ignorieren und „catch“ Blöcke nie leer lassen!
>
Zuerst das das Exception-Objekt erzeugen und dann werfen. Danach
Programm in sicheren Zustand bringen z.B. im „finally“ Block
Ressourcen freigeben
>
Kein „return“ in einem „finally“ Block, da dies die Exception
Behandlung unterbricht
>
Wenn möglich kein „return“ in einem „try“ Block, da dies oft Neulinge
verwirrt
>
Den „finally“ Block verwenden um Ressourcen freizugeben
Mark Egloff 2006
57
Java
Programmierung mit
Exceptions
Tipps
>
Werfe keine Exceptions aus Konstruktoren. Innerhalb von Konstruktoren
sollten keine kritischen Tasks erledigt werden.
>
Verwende kein Exceptionhandling für Programmfluss-Steuerungen
>
Wenn möglich „try/catch“ Blöcke ausserhalb von Schleifen verwenden
>
Weiterleitung von Exceptions beeinflussen die Methodendeklarationen und
die Deklaration der „catch“ Blöcke. Nachträgliches ändern von
Exceptionklassen kann daher eine Kettenreaktion auslösen.
>
Es sollte sehr sorgfältig zwischen „checked“ und „unchecked“ Exception
ausgewählt werden.
>
Anstelle von vielen eigenen Exceptions eine Exceptionklasse mit
Errorcode verwenden. Dies vereinfacht auch die Übersetzung der
Fehlermeldungen im Falle von Mehrsprachigkeit
Mark Egloff 2006
58
Java
Programmierung mit
Exceptions
Zusammenfassung Exceptions
Mark Egloff 2006
59