Fehlerbehandlung in Java - Universität Oldenburg
Fehlerbehandlung in Java - Universität Oldenburg Fehlerbehandlung in Java - Universität Oldenburg
Programmierkurs Java Vorlesung am FB Informatik der Universität Oldenburg Vorlesung 14 Dietrich Boles Programmierkurs Java Vorlesung 14 Dietrich Boles Seite 1
- Seite 2 und 3: Gliederung von Vorlesung 14 • Feh
- Seite 4 und 5: Fehlerbehandlung / Fehlerarten •
- Seite 6 und 7: Fehlerbehandlung / traditionelle Me
- Seite 8 und 9: Fehlerbehandlung in Java / Überbli
- Seite 10 und 11: Fehlerbehandlung in Java / Überbli
- Seite 12 und 13: Fehlerbehandlung in Java / Überbli
- Seite 14 und 15: Fehlerbehandlung in Java / Überbli
- Seite 16 und 17: Fehlerklassen package java.lang; pu
- Seite 18 und 19: Fehlertypdeklaration • Die Fehler
- Seite 20 und 21: „Abfangen“ von Fehlerobjekten
- Seite 22 und 23: „Abfangen“ von Fehlerobjekten E
- Seite 24 und 25: catch-Block • Sehr große Ähnlic
- Seite 26 und 27: Exceptions / Anmerkungen • Fehler
- Seite 28 und 29: Dokumentation / javadoc • javadoc
- Seite 30 und 31: javadoc-Beispiel /** * The buffer w
- Seite 32: Bezeichnerkonventionen • Klassen:
Programmierkurs <strong>Java</strong><br />
Vorlesung<br />
am FB Informatik<br />
der <strong>Universität</strong> <strong>Oldenburg</strong><br />
Vorlesung 14<br />
Dietrich Boles<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 1
Gliederung von Vorlesung 14<br />
• <strong>Fehlerbehandlung</strong><br />
– Motivation<br />
– Fehlerarten<br />
– Fehlerquellen<br />
– traditionelle <strong>Fehlerbehandlung</strong><br />
– <strong>Fehlerbehandlung</strong> <strong>in</strong> <strong>Java</strong><br />
– Fehlerklassen<br />
– Fehlertypdeklaration<br />
– „Werfen“ von Fehlerobjekten<br />
– „Abfangen“ von Fehlerobjekten<br />
– catch-Block<br />
– f<strong>in</strong>ally-Block<br />
– Anmerkungen<br />
• Dokumentation<br />
– Motivation<br />
– javadoc<br />
– Konventionen für die<br />
Bezeichnerbenennung<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 2
<strong>Fehlerbehandlung</strong> / Motivation<br />
public class Mathematik {<br />
public static <strong>in</strong>t fak(<strong>in</strong>t n) {<br />
if (n > 0) return n * fak(n-1);<br />
else return 1; // falsch, wenn n < 0 (nicht def.)<br />
}<br />
public static double div(double wert, double durch) {<br />
if (durch != 0.0) return wert/durch;<br />
else return 0.0; // eigentlich falsch (unendlich)<br />
} }<br />
public class Berechnungen {<br />
public static void ma<strong>in</strong>(Str<strong>in</strong>g[] args) {<br />
double e<strong>in</strong>gabe = Term<strong>in</strong>al.readDouble();<br />
System.out.pr<strong>in</strong>tln(fak(e<strong>in</strong>gabe));<br />
System.out.pr<strong>in</strong>tln(div(e<strong>in</strong>gabe, e<strong>in</strong>gabe-2.0));<br />
} }<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 3
<strong>Fehlerbehandlung</strong> / Fehlerarten<br />
• „Schwere“ Fehler Programmabbruch<br />
• „leichte“ Fehler Korrektur<br />
• „schwer“ / „leicht“ unter Umständen situationsabhängig<br />
– Beispiel: Division durch 0<br />
• Programmabbruch<br />
• Aufforderung zur „Neue<strong>in</strong>gabe“<br />
• weitere Frage: Wer soll auf Fehler reagieren?<br />
– Programmierer e<strong>in</strong>er Funktion<br />
– Aufrufende e<strong>in</strong>er Funktion<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 4
<strong>Fehlerbehandlung</strong> / Fehlerquellen<br />
• Inkonsistente Variablenwerte<br />
• ungültige Parameterwerte<br />
• falsche Adressen / Date<strong>in</strong>amen<br />
• nicht erfüllte Vorbed<strong>in</strong>gungen (lesen erst nach Öffnen e<strong>in</strong>er Datei)<br />
• ungültiger Array-Index<br />
• Zugriff auf null-Objekt<br />
• arithmetische Fehler<br />
• ke<strong>in</strong> Speicherplatz mehr vorhanden<br />
• Endlosrekursion<br />
• ...<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 5
<strong>Fehlerbehandlung</strong> / traditionelle Methoden<br />
Ausgabe e<strong>in</strong>er Fehlermeldung:<br />
public class Mathematik {<br />
public static <strong>in</strong>t fak(<strong>in</strong>t n) {<br />
if (n > 0) return n * fak(n-1);<br />
else if (n == 0) return 1;<br />
System.err.pr<strong>in</strong>tln(“ungueltiger Parameter“);<br />
return -1;<br />
} }<br />
public class Berechnungen {<br />
public static void ma<strong>in</strong>(Str<strong>in</strong>g[] args) {<br />
<strong>in</strong>t e<strong>in</strong>gabe = Term<strong>in</strong>al.readInt();<br />
System.out.pr<strong>in</strong>tln(fak(e<strong>in</strong>gabe));<br />
} }<br />
Problem: Aufrufendes Programm bekommt den Fehler nicht mit!<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 6
<strong>Fehlerbehandlung</strong> / traditionelle Methoden<br />
Benutzung e<strong>in</strong>er error-Variablen:<br />
public class Mathematik {<br />
public static f<strong>in</strong>al <strong>in</strong>t NOERROR = 0;<br />
public static f<strong>in</strong>al <strong>in</strong>t INVALID = 1;<br />
public static <strong>in</strong>t error;<br />
public static <strong>in</strong>t fak(<strong>in</strong>t n) {<br />
if (n > 0) { error = NOERROR; return n*fak(n-1); }<br />
if (n == 0) { error = NOERROR; return 1; }<br />
error = INVALID; return -1;<br />
} }<br />
ma<strong>in</strong>:<br />
<strong>in</strong>t e<strong>in</strong>gabe = Term<strong>in</strong>al.readInt();<br />
<strong>in</strong>t result = fak(e<strong>in</strong>gabe);<br />
if (Mathematik.error == Mathematik.NOERROR)<br />
System.out.pr<strong>in</strong>tln(result);<br />
else if (Mathematik.error == Mathematik.INVALID)<br />
System.err.pr<strong>in</strong>tln(“ungueltiger Parameter“);<br />
...<br />
Problem: Ausgesprochen umständlich!<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 7
<strong>Fehlerbehandlung</strong> <strong>in</strong> <strong>Java</strong> / Überblick<br />
• Bei der Klassen-/Methodendef<strong>in</strong>ition:<br />
– überlegen, was für Fehler auftreten können<br />
– Def<strong>in</strong>ition und Implementierung geeigneter „Fehlerklassen“<br />
– Erweiterung der Methodensignatur um Angabe möglicher Fehler<br />
– erzeugen und liefern („werfen“) von „Fehlerobjekten“ im Falle e<strong>in</strong>es<br />
Fehlere<strong>in</strong>tritts<br />
• Bei der Klassen-/Methodennutzung:<br />
– beim Aufruf e<strong>in</strong>er Methode ermitteln, welche Fehler pr<strong>in</strong>zipiell auftreten<br />
können<br />
– zunächst „versuchen“, die Methode auszuführen<br />
– falls ke<strong>in</strong> Fehler auftritt, normal weitermachen<br />
– falls e<strong>in</strong> Fehler auftritt, das Fehlerobjekt abfangen und geeignete<br />
<strong>Fehlerbehandlung</strong> e<strong>in</strong>leiten<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 8
<strong>Fehlerbehandlung</strong> <strong>in</strong> <strong>Java</strong> / Überblick<br />
• überlegen, was für Fehler auftreten können<br />
public static <strong>in</strong>t fak(<strong>in</strong>t n) {<br />
if (n > 0)<br />
return n * fak(n-1);<br />
else if (n == 0)<br />
return 1;<br />
else<br />
????????<br />
}<br />
Fehlerquelle: ungültiger aktueller Parameterwert (n < 0)<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 9
<strong>Fehlerbehandlung</strong> <strong>in</strong> <strong>Java</strong> / Überblick<br />
• Def<strong>in</strong>ition und Implementierung geeigneter „Fehlerklassen“<br />
public class InvalidParameter<br />
extends Exception {<br />
<strong>in</strong>t actParamValue;<br />
public InvalidParameter(<strong>in</strong>t value) {<br />
super(“Ungültiger Parameter“);<br />
this.actParamValue = value;<br />
}<br />
public <strong>in</strong>t getParamValue() {<br />
return this.actParamValue;<br />
}<br />
}<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 10
<strong>Fehlerbehandlung</strong> <strong>in</strong> <strong>Java</strong> / Überblick<br />
• Erweiterung der Methodensignatur um Angabe möglicher Fehler<br />
• erzeugen und liefern („werfen“) von „Fehlerobjekten“ im Falle e<strong>in</strong>es<br />
Fehlere<strong>in</strong>tritts<br />
public static <strong>in</strong>t fak(<strong>in</strong>t n)<br />
throws InvalidParameter<br />
{<br />
if (n > 0)<br />
return n * fak(n-1);<br />
else if (n == 0)<br />
return 1;<br />
else {<br />
InvalidParameter errorObj =<br />
new InvalidParameter(n);<br />
throw errorObj;<br />
} }<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 11
<strong>Fehlerbehandlung</strong> <strong>in</strong> <strong>Java</strong> / Überblick<br />
• beim Aufruf e<strong>in</strong>er Methode ermitteln, welche Fehler pr<strong>in</strong>zipiell auftreten<br />
können<br />
public static void doSometh<strong>in</strong>g() {<br />
<strong>in</strong>t e<strong>in</strong>gabe = Term<strong>in</strong>al.readInt();<br />
<strong>in</strong>t result = fak(e<strong>in</strong>gabe);<br />
for (<strong>in</strong>t i=0; i
<strong>Fehlerbehandlung</strong> <strong>in</strong> <strong>Java</strong> / Überblick<br />
• zunächst „versuchen“, die Methode auszuführen<br />
• falls ke<strong>in</strong> Fehler auftritt, normal weitermachen<br />
public static void doSometh<strong>in</strong>g() {<br />
try {<br />
<strong>in</strong>t e<strong>in</strong>gabe = Term<strong>in</strong>al.readInt();<br />
<strong>in</strong>t result = fak(e<strong>in</strong>gabe);<br />
for (<strong>in</strong>t i=0; i
<strong>Fehlerbehandlung</strong> <strong>in</strong> <strong>Java</strong> / Überblick<br />
• falls e<strong>in</strong> Fehler auftritt, das Fehlerobjekt abfangen und geeignete<br />
<strong>Fehlerbehandlung</strong> e<strong>in</strong>leiten<br />
public static void doSometh<strong>in</strong>g() {<br />
try {<br />
<strong>in</strong>t e<strong>in</strong>gabe = Term<strong>in</strong>al.readInt();<br />
<strong>in</strong>t result = fak(e<strong>in</strong>gabe);<br />
for (<strong>in</strong>t i=0; i
Fehlerklassen<br />
Object<br />
Throwable<br />
Error<br />
OutOfMemoryError ...<br />
Exception<br />
RuntimeException<br />
...<br />
ArithmeticException<br />
...<br />
• Error: schwerwiegende Fehler<br />
• Runtime: schwerwiegende Fehler<br />
• möglichst neue Fehlerklassen nicht von Error und Runtime ableiten<br />
• neue Fehlerklassen i.a. von Exception ableiten!<br />
• Fehlerobjekte (Exceptions) s<strong>in</strong>d Objekte von Fehlerklassen (von Throwable<br />
(zumeist <strong>in</strong>direkt) abgeleitete Klassen!)<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 15
Fehlerklassen<br />
package java.lang;<br />
public class Exception extends Throwable {<br />
// Konstruktoren<br />
public Exception();<br />
public Exception(Str<strong>in</strong>g message);<br />
// Methoden<br />
public Str<strong>in</strong>g getMessage(); // liefert message<br />
public Str<strong>in</strong>g toStr<strong>in</strong>g(); // ruft getMessage auf<br />
}<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 16
Fehlertypdeklaration<br />
• Deklaration von Fehlertypen e<strong>in</strong>er Methode <strong>in</strong> der Methodensignatur mittels<br />
des Schlüsselwortes throws<br />
• E<strong>in</strong>e Methode muss alle Fehlertypen deklarieren, die sie werfen kann, (oder<br />
sie muss sie selbst „abfangen“) (Fehlerobjekte werden „weitergeleitet“)<br />
• Error- und RuntimeException-Fehler müssen nicht unbed<strong>in</strong>gt<br />
deklariert werden<br />
public class Ex1 extends Exception {}<br />
public class Ex2 extends Exception {}<br />
public <strong>in</strong>t f() throws Ex1, Ex2 {<br />
... if (...) throw new Ex1(); ...<br />
... if (...) throw new Ex2(); ...<br />
}<br />
public <strong>in</strong>t g() throws Ex1 {<br />
try { ... <strong>in</strong>t i = f(); ... } catch (Ex2 e) {...}<br />
}<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 17
Fehlertypdeklaration<br />
• Die Fehlertypdeklaration gehört mit zur Signatur e<strong>in</strong>er Methode<br />
• Werden Methoden mit Fehlertypen <strong>in</strong> abgeleiteten Klassen überschrieben,<br />
dann müssen die Fehlertypdeklarationen übere<strong>in</strong>stimmen oder es müssen<br />
Fehlerklassen angegeben werden, die von den Fehlerklassen der<br />
überschriebenen Methode abgeleitet s<strong>in</strong>d!<br />
public class Ex1 extends Exception {}<br />
public class Ex2 extends Exception {}<br />
public class Ex3 extends Ex2 {}<br />
public class A {<br />
public <strong>in</strong>t f(float v) throws Ex1, Ex2 { ... }<br />
}<br />
public class B extends A { // nur e<strong>in</strong>e der Alternat.<br />
public <strong>in</strong>t f(float v) throws Ex1, Ex2 { ... }<br />
public <strong>in</strong>t f(float v) throws Ex1, Ex3 { ... }<br />
}<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 18
„Werfen“ von Fehlerobjekten<br />
• „Werfen“ von Fehlerobjekten mittels des Schlüsselwortes throw<br />
• nach dem Werfen e<strong>in</strong>es Fehlerobjektes wird e<strong>in</strong>e Methode (wie beim return)<br />
direkt verlassen<br />
• Es können nur Objekte solcher Fehlerklassen geworfen werden, die auch <strong>in</strong> der<br />
Methodendeklaration aufgeführt s<strong>in</strong>d<br />
public class InvalidParam extends Exception {}<br />
public class Math {<br />
public static <strong>in</strong>t fak(<strong>in</strong>t n) throws InvalidParam {<br />
if (n < 0) throw new InvalidParam();<br />
if (n == 0) return 1;<br />
return n * fak(n-1);<br />
}<br />
}<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 19
„Abfangen“ von Fehlerobjekten<br />
• Methoden, die (andere) Methoden aufrufen, die Fehlerobjekte werfen können,<br />
können diese entweder weiterleiten (an die aufrufende Methode dieser<br />
Methode) oder sie müssen sie abfangen (und behandeln)<br />
• Zum Abfangen e<strong>in</strong>es Fehlerobjektes muss die entsprechende Methode <strong>in</strong>nerhalb<br />
e<strong>in</strong>es sogenannten try-Blockes aufgerufen werden<br />
• Die <strong>Fehlerbehandlung</strong> wird <strong>in</strong> e<strong>in</strong>em sogenannten<br />
„den Fehlertyp matchenden“-catch-Block durchgeführt<br />
• wird e<strong>in</strong> Fehlerobjekt geworfen, so wird die Bearbeitung des try-Blockes<br />
unmittelbar beendet<br />
• existiert e<strong>in</strong> matchender-catch-Block, werden die Anweisungen dieses Blockes<br />
ausgeführt<br />
• existiert e<strong>in</strong> sogenannter f<strong>in</strong>ally-Block, wird dieser auf jeden Fall ausgeführt<br />
• wird e<strong>in</strong> Fehlerobjekt während der Abarbeitung e<strong>in</strong>es try-Blockes geworfen und<br />
existiert ke<strong>in</strong> matchender-catch-Block, so wird falls vorhanden der f<strong>in</strong>ally-<br />
Block ausgeführt und anschließend die Methode sofort verlassen und das<br />
Fehlerobjekt an die aufrufende Methode weitergeleitet<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 20
„Abfangen“ von Fehlerobjekten<br />
public <strong>in</strong>t f(double v) throws Ex1, Ex2, Ex3 { ... }<br />
public float g(<strong>in</strong>t i) throws Ex1, Ex3, Ex4 { ... }<br />
public void h() throws Ex3 {<br />
... (*1)<br />
try {<br />
... (*2)<br />
<strong>in</strong>t r = f(2.0);<br />
... (*3)<br />
float x = g(r);<br />
... (*4)<br />
}<br />
catch (Ex1 errorEx1) { ... (*5) }<br />
catch (Ex2 errorEx2) { ... (*6) }<br />
catch (Ex4 errorEx4) { ... (*7) }<br />
f<strong>in</strong>ally { ... (*8) }<br />
... (*9)<br />
}<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 21
„Abfangen“ von Fehlerobjekten<br />
Erläuterungen (zum Beispiel vorher):<br />
(1)wird die Funktion h (bspw. von e<strong>in</strong>er Funktion s) aufgerufen, dann wird<br />
zunächst (*1) ausführt<br />
(2)anschließend wird (*2) ausgeführt<br />
(3)wird während der Ausführung der Funktion f ke<strong>in</strong> Fehlerobjekt geworfen,<br />
dann wird (*3) ausgeführt (weiter bei (6))<br />
(4)wird während der Ausführung der Funktion f e<strong>in</strong> Fehlerobjekt vom Typ<br />
Ex3 geworfen, dann wird zunächst (*8) ausgeführt und danach die Funktion<br />
h unmittelbar verlassen und das Fehlerobjekt an die aufrufende Funktion s<br />
weitergeleitet<br />
(5)wird während der Ausführung der Funktion f e<strong>in</strong> Fehlerobjekt vom Typ<br />
Ex1 (oder Ex2) geworfen, dann wird dieses Objekt (wie bei der<br />
Parameterübergabe) als aktueller Parameter dem formalen Parameter<br />
errorEx1 (bzw. errorEx2) übergeben und (*5) (bzw. (*6)) ausgeführt (weiter<br />
bei (10))<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 22
„Abfangen“ von Fehlerobjekten<br />
(6)nach der Ausführung von (*3) wird die Funktion g aufgerufen<br />
(7)wird während der Ausführung der Funktion g ke<strong>in</strong> Fehlerobjekt geworfen,<br />
dann wird (*4) ausgeführt (weiter bei (10))<br />
(8)wird während der Ausführung der Funktion g e<strong>in</strong> Fehlerobjekt vom Typ<br />
Ex3 geworfen, dann wird zunächst (*8) ausgeführt und danach die Funktion<br />
h unmittelbar verlassen und das Fehlerobjekt an die aufrufende Funktion s<br />
weitergeleitet<br />
(9)wird während der Ausführung der Funktion g e<strong>in</strong> Fehlerobjekt vom Typ<br />
Ex1 (oder Ex4) geworfen, dann wird dieses Objekt (wie bei der<br />
Parameterübergabe) als aktueller Parameter dem formalen Parameter<br />
errorEx1 (bzw. errorEx4) übergeben und (*5) (bzw. (*7)) ausgeführt<br />
(10)nach Ausführung von (*4), (*5), (*6) oder (*7) wird auf jeden Fall (*8)<br />
ausgeführt<br />
(11)anschließend wird (*9) ausgeführt und die Funktion beendet<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 23
catch-Block<br />
• Sehr große Ähnlichkeiten zu Prozeduren und Parametern<br />
• muss e<strong>in</strong>em try-Block (oder e<strong>in</strong>em anderen catch-Block) folgen<br />
• „formale Parameter“ müssen Fehlerklassen/-Objekte se<strong>in</strong>, die im try-Block<br />
auftreten können (bzw. Oberklassen der Fehlerklassen (→ Polymorphie))<br />
• die Fehlerobjektübergabe ist identisch zur Parameterübergabe bei Funktionen,<br />
d.h. <strong>in</strong>sbesondere können die formalen Fehlerobjekte wie lokale Variablen des<br />
catch-Blockes behandelt werden; sie werden mit dem geworfenen Fehlerobjekt<br />
<strong>in</strong>itialisiert<br />
• wird während der Ausführung des try-Blockes e<strong>in</strong> Fehlerobjekt geworfen, so<br />
wird der try-Block verlassen, und es wird der Reihe nach (!) überprüft, ob e<strong>in</strong><br />
catch-Block mit dem Fehlerobjekt matched; dabei gilt:<br />
• e<strong>in</strong> catch-Block matched e<strong>in</strong> aktuelles Fehlerobjekt, wenn die Klasse se<strong>in</strong>es<br />
formalen Fehlerobjektes gleich der Klasse oder e<strong>in</strong>e Oberklasse des aktuellen<br />
Fehlerobjektes ist<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 24
f<strong>in</strong>ally-Block<br />
• ist „parameterlos“<br />
• schließt e<strong>in</strong>en try-{catch}*-Block ab, d.h. kann h<strong>in</strong>ter e<strong>in</strong>em bzw. e<strong>in</strong>er Menge<br />
von catch-Blöcken def<strong>in</strong>iert werden<br />
• ist e<strong>in</strong> f<strong>in</strong>ally-Block h<strong>in</strong>ter e<strong>in</strong>em try-{catch}*-Block vorhanden, so wird dieser<br />
auf jeden Fall ausgeführt, d.h.<br />
– wenn ke<strong>in</strong> Fehlerobjekt im try-Block geworfen wurde<br />
– wenn e<strong>in</strong> Fehlerobjekt im try-Block geworfen und nicht abgefangen wurde<br />
(nach dem f<strong>in</strong>ally-Block wird <strong>in</strong> diesem Fall die Funktion verlassen und das<br />
Fehlerobjekt an die aufrufenden Funktion weitergeleitet)<br />
– wenn e<strong>in</strong> Fehlerobjekt im try-Block geworfen und abgefangen wurde, d.h.<br />
nach der Ausführung des matchenden catch-Blockes<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 25
Exceptions / Anmerkungen<br />
• Fehlerquelle: werden während der Ausführung e<strong>in</strong>es try-Blockes explizit<br />
Fehlerobjekte geworfen, können diese u.U. (d.h. es existiert e<strong>in</strong> matchender<br />
catch-Block) direkt wieder von e<strong>in</strong>em catch-Block gefangen werden:<br />
class Ex1 extends Exception {}<br />
public void f() {<br />
try { ... throw new Ex1(); ...<br />
} catch (Exception obj) { ... }<br />
}<br />
• es kann passieren, dass auch während der Abarbeitung e<strong>in</strong>es catch-Blockes<br />
wieder Fehler auftreten (→ Schachtelung):<br />
...<br />
catch (Exception o) {<br />
try { ... } catch (Exception obj2) { ... }<br />
}<br />
• auch try-{catch}*f<strong>in</strong>ally-Blöcke lassen sich schachteln<br />
• rücksichtsloses Abbrechen e<strong>in</strong>es Programms: System.exit(0);<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 26
Dokumentation<br />
• 2 Typen von Source-Code-Dokumentation:<br />
– Dokumentation des Protokolls<br />
– Dokumentation der Implementierung<br />
• Motivation:<br />
– Beschreibung der Funktionalität e<strong>in</strong>er Klasse / Methode für andere<br />
Programmierer<br />
– bessere Verständlichkeit der gewählten Algorithmen<br />
– e<strong>in</strong>fachere Fehlersuche und Fehlerbeseitigung<br />
– e<strong>in</strong>fachere Wartung, Änderbarkeit und Erweiterbarkeit des Codes<br />
• Dokumentation der Implementierung <strong>in</strong> <strong>Java</strong>:<br />
– aussagekräftige Bezeichner (Klassen / Methoden / Variablen) verwenden<br />
– den Code gut strukturieren<br />
– an „kritischen“ Stellen Zeilenkommentare e<strong>in</strong>bauen<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 27
Dokumentation / javadoc<br />
• javadoc: Werkzeug des JDK zur Generierung von HTML-Code zur<br />
Dokumentation des Protokolls e<strong>in</strong>er oder mehrerer Klassen:<br />
• Aufruf: javadoc <br />
• Voraussetzung: Verwendung von javadoc-Kommentaren und javadoc-<br />
Schlüsselwörtern<br />
• javadoc-Kommentare: /** */<br />
• javadoc-Schlüsselwörter:<br />
– Beschreibung von Klassen:<br />
Beschreibung der Funktionalität<br />
@version <br />
@author <br />
– Beschreibung von Methoden:<br />
• Beschreibung der Funktionalität<br />
• Vorbed<strong>in</strong>gungen, Nachbed<strong>in</strong>gungen<br />
• @param <br />
• @return <br />
• @exception <br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 28
javadoc-Beispiel<br />
package java.util;<br />
/**<br />
* Vector class (a growable array).<br />
*<br />
* Each vector tries to optimize storage management by ma<strong>in</strong>ta<strong>in</strong><strong>in</strong>g<br />
* a capacity and a capacityIncrement. The capacity is always at<br />
* least as large as the vector size; it is usually larger because<br />
* as elements are added to the vector, the vector's storage<br />
* <strong>in</strong>creases <strong>in</strong> chunks the size of capacityIncrement. Sett<strong>in</strong>g<br />
* the capacity to what you want before <strong>in</strong>sert<strong>in</strong>g a large number of<br />
* objects will reduce the amount of <strong>in</strong>cremental reallocation.<br />
* You can safely ignore the capacity and the vector will still work<br />
* correctly.<br />
*<br />
* @version 1.29, 01 Dec 1995<br />
* @author Jonathan Payne<br />
* @author Lee Boynton<br />
*/<br />
public class Vector implements Cloneable {<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 29
javadoc-Beispiel<br />
/**<br />
* The buffer where elements are stored.<br />
*/<br />
protected Object element_data[];<br />
/**<br />
* The number of elements <strong>in</strong> the buffer.<br />
*/<br />
protected <strong>in</strong>t element_count;<br />
/**<br />
* Constructs an empty vector with the specified storage<br />
* capacity.<br />
* @param <strong>in</strong>itial_capacity the <strong>in</strong>itial storage capacity of the<br />
* vector<br />
*/<br />
public Vector(<strong>in</strong>t <strong>in</strong>itial_capacity) { ... }<br />
/**<br />
* Constructs an empty vector.<br />
*/<br />
public Vector() { ... }<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 30
javadoc-Beispiel<br />
/**<br />
* Returns the element at the specified <strong>in</strong>dex.<br />
* @param <strong>in</strong>dex the <strong>in</strong>dex of the desired element<br />
* @return the element at the specified <strong>in</strong>dex<br />
* @exception ArrayIndexOutOfBoundsException If an <strong>in</strong>valid<br />
* <strong>in</strong>dex was given.<br />
*/<br />
public f<strong>in</strong>al synchronized Object elementAt(<strong>in</strong>t <strong>in</strong>dex) { ... }<br />
/**<br />
* Sets the element at the specified <strong>in</strong>dex to be the specified<br />
* object.<br />
* The previous element at that position is discarded.<br />
* @param obj what the element is to be set to<br />
* @param <strong>in</strong>dex the specified <strong>in</strong>dex<br />
* @exception ArrayIndexOutOfBoundsException If the <strong>in</strong>dex was<br />
* <strong>in</strong>valid.<br />
*/<br />
public f<strong>in</strong>al synchronized<br />
void setElementAt(Object obj, <strong>in</strong>t <strong>in</strong>dex) { ... }<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 31
Bezeichnerkonventionen<br />
• Klassen:<br />
– Anfangsbuchstaben jedes Wortteils groß<br />
• DibosGobangProgramm<br />
• ArrayIndexOutOfBoundsException<br />
• Attribute / Variablen:<br />
– Beg<strong>in</strong>n mit Kle<strong>in</strong>buchstaben; Anfangsbuchstaben weiterer Wortteile groß<br />
• anzahlAnZeichen<br />
• maximaleGroesse<br />
• Methoden:<br />
– Beg<strong>in</strong>n mit Kle<strong>in</strong>buchstaben; Anfangsbuchstaben weiterer Wortteile groß<br />
• getNumber<br />
• liefereNaechstenSpielzug<br />
• Konstanten:<br />
– ausschließlich Großbuchstaben; Trennung von Wortteilen durch<br />
Unterstrich (_)<br />
• MAX_VALUE<br />
• INVALID_PARAM<br />
Programmierkurs <strong>Java</strong> Vorlesung 14 Dietrich Boles Seite 32