9. Ausnahmebehandlung

Transkript

1 9. Ausnahmebehandlung 9.1 Motivation: Defensives Programmieren 9.2 Anforderungen an Programmiersprachen 9.3 Ausnahmebehandlung in Java 9.4 Laufzeitfehler und Ausnahmen 9.5 Aufräumarbeiten 9.6 C# und Java, Zusammenfassung

2 9.1 Defensives Programmieren Programmfehler (error, bug): fehlerhaftes Programmverhalten, dem Programmentwickler während der Programmierung nicht bewusst. Ausnahmesituation (exception) fehlerhaftes Programmverhalten, dessen Ursache beim Programmieren bekannt ist also im Programm berücksichtigt werden sollte Beispiele für Ausnahmen: (1) int i = readint("zahl eingeben:") Ganze Zahl eingegeben? wenn nicht: etwas unternehmen. (2) double d = quot (double d); { return (d/readdouble()); // could be 0! hs / fub - alp2-08 2

3 Unter defensivem Programmieren versteht man die Berücksichtigung möglichst vieler (aller?) Situationen, die Fehlverhalten des Programms antizipieren und dagegen Maßnahmen mit Mitteln der Programmiersprache ergreifen. Maßnahmen: abhängig von der Art des Fehlers oder (schlechte Lösungen!): - ignorieren ("on error resume") - unbedingter Programmabbruch Mittel: sehr unterschiedlich in verschiedenen Sprachen (s.u.) Gegenteil von defensivem Programmieren: Fehler ignorieren und fortfahren. hs / fub - alp2-08 3

4 Programmiersprachliche Mittel 1. Keine. Ausnahmen in Programmlogik abfragen und über Rückgabecode (return code) signalisieren. Beispiele: Praktisch alle "alten" Sprachen (C, FORTRAN, COBOL, Modula2)... int search(value v){ while (i>0) { if (i==0) return -1; // not found else {return i;... int ret = myarr.search(myval); if (ret==-1) return -1; else... //continue processing... hs / fub - alp2-08 4

5 Ohne geeignete Sprachkonstrukte: Ausnahmebehandlung vermischt mit produktivem Code - Vermischung von Rückgabewert (im Bsp: 1..MAX) und Fehlerstatus ( etwa int < 0 ) - unübersichtlich, kaskadierende Fallunterscheidungen Fehlerbehandlung oft nicht durch Aufrufenden sondern nach höher in Aufrufhierarchie, evtl. abhängig vom Fehler.. int i = f(); if (i<0) {..print(".."); exit; else.. int f(){.. j = g(x); if (j <-1) return j; else {if j== -1) g(x+1); else... int g(x) {... if(except_1) return -3; if(except_2) return -1;... else return val;.. hs / fub - alp2-08 5

6 9.2 Anforderungen an Konstrukte zur Systematisierung der Ausnahmebehandlung - Produktiven Code und Ausnahmebehandlung trennen - Programmbereiche, in denen bestimmte Ausnahmen auftreten können, einzäunen. - Ausnahmen signalisieren oder - Ausnahmen direkt behandeln. - Ausnahmen, die vom Laufzeitsystem signalisiert werden, behandeln. - Ausnahmen implizit über Aufrufhierarchien hinweg "werfen". - Fehler subsumieren, z.b. "Dateilesefehler" subsumiert "Kein Leserecht" - Möglichst flexible Ausnahmebehandlung ermöglichen hs / fub - alp2-08 6

7 Beispiel public static void main( String args[] ){ String filename = SimpleIO.kbdInput.readString("Dateiname > "); RandomAccessFile f; f = new RandomAccessFile( filename, "r" ); for ( String line; (line=f.readline())!= null; ) {System.out.println( line ); Mögliche Fehler: - Falscher Dateiname noch mal versuchen? - Sonstiger Fehler (kein Leserecht? ) - Fehlermeldung Beachte: Fehlerbehandlung ist Aufgabe des Aufrufenden (caller) nicht des Aufgerufenen (callee) hs / fub - alp2-08 7

8 9.4. Ausnahmebehandlung in Java public static void main( String args[] ){ String filename = SimpleIO.kbdInput.readString("Dateiname > "); try{ RandomAccessFile f; f = new RandomAccessFile( filename, "r" ); for ( String line; (line=f.readline())!= null; ) {System.out.println( line ); catch( FileNotFoundException e ) {System.err.println( "Datei gibt es nicht!" ); catch ( IOException e ) {System.err.println( " Leseprobleme!" ); Ausnahmen werden inner halb eines try Blocks als Objekte geworfen hier von RandomAccesfile f und in einem catch-block behandelt oder weitergeworfen (s.u.) hs / fub - alp2-08 8

9 Behandlung von Ausnahmen (1) public static void main( String args[] ){ try{ String filename = SimpleIO.kbdInput.readString("Dateiname > "); RandomAccessFile f; f = new RandomAccessFile( filename, "r" ); for ( String line; (line=f.readline())!= null; ) {System.out.println( line ); catch( FileNotFoundException e ) wird von RandomaccessFile ausgelöst. Kein Java {System.err.println( "Datei gibt es nicht!" ); retry(n)... Manchmal sinnvoll: Zweiter (n-ter) Versuch Rückkehr in den eingezäunten Code-Block. In Java nicht möglich. hs / fub - alp2-08 9

10 try-catch Syntax try { <statements > * catch (AusnahmeId Name) { <Ausnahmebehandlung> [catch (AusnahmeId Name) { <Ausnahmebehandlung>] 0 n Ausnahme wird durch try-block abgefangen und durch ersten passenden catch-block behandelt oder weiter geworfen (throw) (*) Geschachtelte try-blöcke möglich! hs / fub - alp

11 Entstehen und Weiterreichen von Ausnahmen 1. Innerhalb eines try-blocks oder einer Methode wird Ausnahme gemeldet (geworfen). Direkte Konsequenz: direkte umschließender try-block oder Methode (falls kein try-block) wird abgebrochen. 2. Werfen: explizit durch throw = new Exception() oder 3. Durch Abbruch eines try-block oder einer Methode infolge Ausnahme, die nicht behandelt wird. hs / fub - alp

12 main( ) { h(x);... void h(int x) { throws AnException {.. try{ g(x); catch (AnException e){.. void g(char x) throws AnException {... Merke: Geworfen wird immer nur zum Aufrufenden. Der behandelt die Ausnahme oder wirft sie weiter. Wenn main Ausnahme nicht behandelt: Programmabbruch. hs / fub - alp

13 Behandeln von Ausnahmen (2) Selbst behandeln in try{ catch() { Block, Block wird in jedem Fall verlassen. Weiterreichen an Folge der Aufrufenden bis passender catch-block gefunden dort behandeln. Falls kein passender gefunden wird: Abbruch von main Weiterwerfen von AnException setzt throws AnException in Signatur voraus. Fehlermeldung vom Übersetzer, wenn aufgerufene Methode mögliche Ausnahme durch throws signalisiert, aber die nicht vom Aufrufenden behandelt oder weitergeworfen wird. Fortsetzung des Programms nach dem Block mit der catch-anweisung, die die Ausnahme behandelt ("gefangen") hat. hs / fub - alp

14 9.4 Laufzeitfehler (run time exceptions) z.b. NullPointerException, IndexOutOfBoundException, ArithmeticException, NumberFormatConversion und andere werden automatisch vom Laufzeitsystem gemeldet und müssen nicht in der Signatur angekündigt werden. heißen ungeprüfte Ausnahmen (unchecked exceptions) können abgefangen werden Erklärt, warum wir uns um ArithmeticException bisher nicht kümmern mussten. hs / fub - alp

15 Abfangen von Laufzeitfehlern manchmal sinnvoll: while ( true ) { try { int number = kbdinput.readint("zahl: "); break; catch ( NumberFormatException e ) nur zur Demo: Tatsächlich fängt readint() die Ausnahme schon ab. {System.out.println( "Format? Nochmal eingeben"); Auch ein Beispiel für Nachbildung des Rücksprungs "in den Block", der Ausnahme ausgelöst hat. hs / fub - alp

16 9.5 Aufräumarbeiten Motivation: Wird ein Block nicht über das Blockende verlassen, können unerwünschte Restzustände bleiben. Verlassen des Blocks durch: - Unbehandelte Ausnahme - Behandelte Ausnahme - return (!) try {<statements> [catch clause] 0 1 [finally {<statements>] 0 1 hs / fub - alp

17 Beispiel: Feldsuche mit sentinel static int search (int arg) throws Exception { myarray[0] = arg; // set sentinel int i; try { for (i =myarray.length-1; myarray[i]!=arg;i-- ); if (i> 0)return i; else throw new Exception ("Value "+arg +" not found."); catch (IndexOutOfBoundsException e) {throw new Exception("should not happen"); finally {myarray[0] = -1; // unset sentinel finally Block wird hier in jedem Fall ausgeführt! hs / fub - alp

18 Alles oder Nichts-Prinzip Operation soll nur Effekte haben, wenn keine Ausnahme vorkommt. void foo(point p) { p.x +=10; try{ p.y = kbdinput("neue y-koordinate "); catch (IOException e){... finally {p.x -=10 Besser: ausnahmebedrohte Operationen vor Änderungen durchführen. Oder wie oben: Effekte kompensieren in finally-block hs / fub - alp

19 Ausnahmehierarchie Klassenhierarchie ermöglicht gezielte Ausnahmebehandlung etwa: IndexOutOfBoundException subsumiert ArrayIndexOutOfBoundException und String IndexOutOfBoundException Basiert im Wesentlichen auf dem Vererbungskonzept (später) Eigene Ausnahmen: entsprechende Klassen definieren. hs / fub - alp

20 Nochmal: andere Programmiersprachen C# Konzeptionell wie in Java mit.. wesentlicher Ausnahme Ausnahmen können, müssen nicht behandelt werden! Vorteil: handlichere Programmierung Nachteil: Software weniger robust. Konsequenzen Kein Unterschied von checked exception unchecked exception (Laufzeitfehler, die nicht abgefangen werden müssen) throws in Methodensignatur nicht nötig (gibt's auch nicht in C#) hs / fub - alp

21 Java void foo() throws IOException{... throw new IOException();... Aufrufende von foo müssen entweder - IOException abfangen oder - IOException in eigener Signatur angeben C# void foo() {... throw new IOException();... Aufrufende von foo können IOException abfangen oder nicht + handlicheres Programmieren - weniger robuste Programme hs / fub - alp