Sie sind auf Seite 1von 16

Exception Handling in Java

Seminar aus
Softwareentwicklung

Norbert Wiener
Ziele von Exception Handling
 Programme robuster machen gegen:
• fehlerhafte Eingaben
• Gerätefehler (Defekte, Platte voll, ...)
• Programmierfehler (z.B. Division durch 0)

 Trennung zwischen Algorithmus und


Fehlerbehandlung

 Fehlerbehandlung durch Compiler überprüfbar


machen
Auslösen von Exception
 explizite Ausnahmen: „throw“ Anweisung im Code.

setPassword(String pw) {
......
if(pw.length() < 5) throw new Exception(„mind. 5 Zeichen“);
.......
}

 implizite Ausnahmen durch die JVM


- Divison durch 0 => ArithmeticException
- Zugriff über null-Ref. => NullPointerException
- Ungültige Konvertierung => ClassCastException

int intDiv (int i, int j) {


return i/j;
}
try-catch-finally Syntax
try {
Anweisungen;
} catch (Ausnahme1 a1) {
Fehlerbehandlung1; Nach einem try-Block
} catch (Ausnahme2 a2) { muss mindestens ein
Fehlerbehandlung2; catch-Block folgen!
} finally {
Aufräumen;
Der finally-Block ist
}
optional

Bei mehreren catch-Blöcken beginnt die


Suche der Ausnahmenbehandlung von
oben nach unten.
Beispiel
class Catch{ Catch 123
public static void main(String[] args){ i= 123 finally!
try{
int i = Integer.parseInt(args[0]); Catch xy
kein int-Wert! finally!
System.out.print("i= "+i);
}catch(ArrayIndexOutOfBoundsException e){
Catch
System.out.print("Parameter vergessen!"); Parameter vergessen! finally!
}catch(NumberFormatException e){
System.out.print(" kein int-Wert!");
}finally{
System.out.println(" finally!");
Finally wird immer
}
ausgeführt!
}
}
Ausnahme-Klasse definieren
class MyException extends Exception{ Eigener Exceptiontyp
} (indirekt) von
Throwable ableiten.

class MyException extends Exception{


public MyException() { Konstuktor ohne
super(); Parameter
}
public MyException(String msg) {
super(msg); Konstruktor mit
}
Fehlermeldung
}
Die throws-Klausel
setPassword(String pw) {
try{
if(pw.length() < 5){
throw new Exception(„Fehler“);
}
}catch(Exception e){
Ausnahme behandeln!
}
}

 Weitergabe der Exception an die aufrufende Methode

Try{ static setPassword(String pw)


setPassword(pw); throws Exception {
}catch(Exception e){ if(pw.length() < 5){
Ausnahme behandeln! throw new Exception(„Fehler“);
} }.......
}
throws Beispiel
........ ........ C(int x)
..Main(...){ throws Exc1, Exc2 ,Exc3 {
A(int x) B(int x)
...... try{
throws Exc1{ throws Exc1, Exc2{
try{
if(x==1){
A(x); try{ try{
throw new Exc1("F.");
}catch(Exc1 e){ B(x); C(x);
..print("Main"); }catch(Exc2 e){ }catch(Exc3 e){ }else if(x==2){
} throw new Exc2();
...println("A"); ...println("B");
........
}else if(x==3){
}finally{ }finally{
throw new Exc3();
..println("finA") ...println("finB");
}else{
} }
throw new Exc4();
} }
}
}catch(Exc4 e){
x=1 x=2 x=3 x=4
....println("C");
finB finB B C
}
finA A finB finB
}
Main finA finA finA
Debugging von Ausnahmen
e.getMessage()
class Test{
static int x =1; e.printStackTrace()
public static void main(String args[]) {
try{
A a= new A(x); finB
finA
}catch(Exc1 e){
Main
System.out.println("Main"); Fehler!
System.out.println(e.getMessage()); Exc1: Fehler!
e.printStackTrace(); at C.<init>(C.java:6)
at B.<init>(B.java:4)
}
at A.<init>(A.java:4)
} at Test.main(Test.java:6)
}
Klassenhierarchie
Throwable

Error Exception

VirtualMachineError LinkageError RuntimeException IOException

NullpointerException FileNotFoundException
OutOfMemoryError NoSuchFieldError

unchecked checked
Die Error-Klasse
 VirtualMachineError Ausnahmen des
 InternalError Typs Error sind
 OutOfMemoryError nicht vernünftig
 StackOverflowError zu behandeln.
 UnknownError
 LinkageError
 NoSuchMethodError
 NoSuchFieldError
 AbstraktMethodError
 ThreadDeath
Die Exception Klasse
 IOException Diese Exception
 FileNotFoundException müssen behandelt
 SocketException werden!
 EOFException (ausgenommen
RuntimeException)
 RemouteException
 UnknownHostException
 InterruptedException
 NoSuchFieldException
 ClassNotFoundException
 NoSuchMethodException
Exception auf ByteCode Ebene
void f() {
Exception e;
try { e = new Exception();
throw new Exception(); throw e; Adr.-> Exception
} catch (Exception e) { Adr.-> Exception
System.out.println(e);
} Operanden-Stack
}
Objekt im Speicher allokieren
Objektreferenz auf OperantenStack
0 new #2 <Class Exception>
3 dup
Referenzadresse wird dupliziert
4 invokespecial <init>
7 athrow
8 astore_1 Konstruktor wird ausgeführt
9 getstatic out:System
12 aload_1
13 invokevirtual println
Exception Table:
16 return From To Target Type
0 8 8 Exception
Beispiel
static int remainder(int dividend, int divisor)
throws OverflowException, DivideByZeroException Exception Handling
{ wird an die
if ((dividend == Integer.MIN_VALUE) && Vorgängermethode
(divisor == -1)) { delegiert!
throw new OverflowException();
}
try {
return dividend % divisor;
}
catch (ArithmeticException e) {
throw new DivideByZeroException();
}
}
0 iload_0
1 ldc #1 <Integer - 2147483648>

Beispiel
3 if_icmpne 19
6 iload_1
7 iconst_m1
8 if_icmpne 19
static int remainder(int dividend, int divisor)
11 new #4 <Class
throws OverflowException, DivideByZeroException {
OverflowException>
if ((dividend == Integer.MIN_VALUE) &&
14 dup
(divisor == -1)) {
15 invokespecial #10 <Method
throw new OverflowException();
OverflowException()>
}
18 athrow
try {
return dividend % divisor;
} 19 iload_0
catch (ArithmeticException e) { 20 iload_1
throw new DivideByZeroException(); 21 irem
} 22 ireturn
}
23 pop
24 new #2 <Class DivideByZeroE.>
Exception Table: 27 dup
From To Target Type 28 invokespecial #9 <Method
DivideByZeroException()>
19 23 23 ArithmeticException 31 athrow
Danke für
die Aufmerksamkeit