Programmierkurs Kapitel 10 Grundlagen von Exceptions 10.1

Kapitel 10
Programmierkurs
Exceptions
Behandlung von Exceptions
Verschiedene Exceptions
Mehrere catch-Anweisungen
Der finally-Block
Birgit Engels
Anna Schulze
Zentrum für Angewandte Informatik
Köln
WS 07/08
1 / 23
2 / 23
Grundlagen von Exceptions
Exceptions ermöglichen die strukturierte Behandlung von
Fehlern, die während der Programmausführung auftreten
Beispiele, in denen Exceptions verwendet werden:
◮
◮
10.1 Behandlung von Exceptions
Laufzeitfehler, weil ein Array-Zugriff außerhalb der definerten
Grenzen erfolgte
Eine Datei, die geöffnet werden soll, wird nicht gefunden
3 / 23
4 / 23
Die try-catch-Anweisung
try
{
Anweisung;
}
catch (Exception x) {
Anweisung;
}
catch (Exception y) {
Anweisung;
}
Der try-Block enthält dabei Anweisungen, bei deren
Ausführung ein Fehler des Typs Ausnahmetyp auftreten kann.
In diesem Fall wird die normale Programmausführung
unterbrochen und der Programmablauf fährt mit der ersten
Anweisung nach der catch-Klausel fort, die den passenden
Ausnahmetyp deklariert hat
10.2 Verschiedene Exceptions
5 / 23
ArithmeticException
6 / 23
ArithmeticException
public class MyArithmeticException
{
Nach kompilieren mit:
public static void main (String args[])
{
javac MyArithmeticException.java
int i = 0;
Und Aufruf des Programms:
try {
i = 1/i;
java MyArithmeticException
}
Ist die Ausgabe des Programms:
catch(ArithmeticException e) {
System.out.println(‘‘main:
main: ArithmeticException aufgetreten!
ArithmeticException aufgetreten!’’);
}
}
}
7 / 23
8 / 23
ArrayIndexOutOfBoundsException
ArrayIndexOutOfBoundsException
Grundgerüst des Programms:
public static void PrintOut()
public class MyArrayIndexOutOfBoundsException
{
{
for(int i=0;i<N;i++) {
private static String s[] = new String[3];
try {
private static final int N = 4;
System.out.println(‘‘s[i] = ’’+s[i]);
public static void PrintOut()
}
{
catch(ArrayIndexOutOfBoundsException e) {
...
System.out.println(‘‘PrintOut:
}
ArrayIndexOutOfBoundsException
public static void main (String args[])
aufgetreten!’’);
{
}
...
}
}
}
}
9 / 23
ArrayIndexOutOfBoundsException
10 / 23
ArrayIndexOutOfBoundsException
Nach kompilieren mit:
javac MyArrayIndexOutOfBoundsException.java
public static void main (String args[])
Und Aufruf des Programms:
{
s[0] = ‘‘Java’’;
java MyArrayIndexOutOfBoundsException
s[1] = ‘‘ist’’;
Ist die Ausgabe des Programms:
s[2] = ‘‘cool!’’;
PrintOut();
s[0] = Java
System.out.println(‘‘Wieder in main
s[1] = ist
angekommen!’’);
s[2] = cool!
}
PrintOut: ArrayIndexOutOfBoundsException
aufgetreten!
Wieder in main angekommen!
11 / 23
12 / 23
Mehrere catch-Anweisungen
Grundgerüst des Programms:
public class MyMoreCatch
{
private static String s[] = new String[3];
10.3 Mehrere catch-Anweisungen
public static void PrintOut(int N)
{
...
}
public static void main (String args[])
{
...
}
}
13 / 23
Mehrere catch-Anweisungen
14 / 23
Mehrere catch-Anweisungen
public static void PrintOut(int N) {
try {
for(int i=0;i<N;i++)
public static void main (String args[])
System.out.println(‘‘s[i] = ’’ +s[i]);
{
int i = 0;
s[0] = ‘‘Java’’;
i = 1/i;
s[1] = ‘‘ist’’;
}
s[2] = ‘‘cool!’’;
catch(ArrayIndexOutOfBoundsException e) {
PrintOut(3);
PrintOut(4);
System.out.println(‘‘PrintOut: ArrayIndexOutOfBoundsException aufgetreten!’’);
}
}
catch(ArithmeticException e) {
System.out.println(‘‘PrintOut: ArithmeticException aufgetreten!’’);
}
}
15 / 23
16 / 23
Mehrere catch-Anweisungen
Die Ausgabe des Programms:
s[0] = Java
s[1] = ist
10.4 Der finally-Block
s[2] = cool!
PrintOut: ArithmeticException aufgetreten!
s[0] = Java
s[1] = ist
s[2] = cool!
PrintOut: ArrayIndexOutOfBoundsException
aufgetreten!
17 / 23
Der finally-Block
18 / 23
Der finally-Block
Der finally-Block wird immer dann ausgeführt, wenn die
try-Klausel betreten wurde
D.h. der finally-Block wird ausgeführt, wenn der try-Block
durch eine der folgenden Anweisungen verlassen wurde:
try
Das normale Ende des try-Blockes wurde erreicht
{
Eine Exception ist aufgetreten, die durch eine catch-Klausel
behandelt wurde
Anweisung;
}
Eine Exception ist aufgetreten, die nicht durch eine
catch-Klausel behandelt wurde
catch(Exception e)
{
Der try-Block wurde durch eine der Sprunganweisungen
breack, continue oder return verlassen
Anweisung;
}
Die finally-Klausel ist also der Ort, um Aufräumarbeiten
durchzuführen.
Z.B. können Dateien geschlossen werden.
finally
{
Anweisung;
}
19 / 23
20 / 23
Die throw-Anweisung
catch or throw Regel:
Entweder die Exception wird durch catch behandelt
Oder durch throw weitergegeben
Dazu wird an des Ende des Methodenkopfes das Schlüsselwort
throw mit einer Liste aller Ausnahmen, die nicht behandelt
werden sollen, angehängt.
10.5 catch or throw
public static void SqrtTable()
throws ArithmeticException {
double x=-1.0;
while(x <= 10.0) {
System.out.println(‘‘sqrt(’’+x+‘‘)=’’
+Math.sqrt(x));
x+=1.0;
}
21 / 23
Die throw-Anweisung
Wenn eine Methode benutzt wird, dann muss der durch throw
definierte Fehler druch eine catch-Anweisung behandelt
werden oder wiederum mit throw weitergegeben werden.
23 / 23
}
22 / 23