4   Ausnahmebehandlung

Inhalt Verwendung von Ausnahmen ·Definition eigener Ausnahmebehandlung

Literatur: Den entsprechenden Abschnitt aus [Fla99b] oder Abschnitt 14.1 aus [LL97]. Deneben unter anderem die Klassen java.lang.Throwable, java.lang.Error, java.lang.Exception.*

• nicht alle unerwünschten Situationen können statisch überprüft und abgefangen werden ÞExceptions
• disziplinierte Art, den Kontrollfluß abhängig vom (Fehler- ) Verhalten zu steuern
• Zur Steuerung:
  • throw: Signalisierung einer Ausnahmesituation ÞVerlassen des gewöhnlichen Kontrollflusses
  • catch: Definition der Reaktion auf eine Ausnahme
  
  
• Nutzen:
  • saubere Trennung von Normal- und Ausnahmeverhalten, d.h. Ausnahmebehandlung getrennt vom Rest anpassbar (vorteilhaft auch bei der Verwendung fremder Klassen/APIs)
  • Debugging einfacher
  • Typsicherheit

class Div {
  public  static int  division (int z, int n) {
    return z/n;                                        // Zeile 3
  };
};

public class Main {
  public static void main (String[] args) {
    int nenner = 0;
    int zaehler = 0;
    System.out.println(Div.division(zaehler, nenner)); // Zeile 11
  };

  
};

java.lang.ArithmeticException: / by zero
        at Div.division(Main.java:3)
        at Main.main(Main.java:11)

Process Main exited abnormally with code 1

• Ausnahmen sind Objekte, genauer Instanzen von java.lang.Exception (bzw. deren Unterklassen)
• sie implementieren das Interface Throwable²⁷
• Propagieren einer geworfenen Ausnahme durch die lexikalische Blockstruktur bis
  • nach ganz oben (main) oder
  • die Ausnahme abgefangen und behandelt wird (mit catch)
  
  
• Syntax: try ... catch .... [finally].

    try {
      <stmnt_list>
    } catch <excpt_class1> <var1> {
        <stmnt-list_1>}{
      catch <excpt_class2> <var2> {
        <stmnt-list_>2}{
    ....
    }
     finally 
    {
      <stmnt_list_n>
    }
   
  

  • try: führt ein Statement "` unter Vorbehalt"' aus
  • catch: fängt eine geworfene Ausnahme bei Bedarf ab und reagiert darauf, der erste passende catch-Zweig behandelt eine eventuelle Ausnahme.
  • optional finally: wird grundsätzlich ausgeführt (falls vorhanden)

class Div {
  public  static int  division (int z, int n) {
    return z/n;                                     
  };
};
public class Main2 {
  public static void main (String[] args) {
    int nenner   = 0;
    int zaehler  = 0;
    int ergebnis = 0;                                // vorbelegen
    try {
      ergebnis = Div.division(zaehler, nenner); 
    }
    catch (ArithmeticException e) {
      System.out.println("Mir egal, ich rechne weiter");
    };
    System.out.println(ergebnis);
  };
};

  System.out.println(e + ", trotzdem rechne ich weiter");

• Neben Abfangen und Behandeln kann man Ausnahmen auch
  • 
    
    Deklarieren: throws. Kann die Ausführung einer Methode zu einer Ausnahme führen, die nicht abgefangen wird: Deklaration im "`Rückgabetyp"'
    
    

      public void open_file() throws IOException {
        .......           // der Rumpf der Methode
                          // kann scheitern
         }; 
      public void mymethod(..) throws MyExcpt1, MyExcpt2 {
          .....
        };
    

  • Generieren = werfen mittels throw
  • Definieren: da, wie erwähnt, Ausnahmen Objekte sind werden sie als Klassen, genauer als Unterklassen von Exception vereinbart
  • Parameterübergabe zur Fehlerdiagnose (oft ein String) mittels der Konstruktoren

class MyException extends Exception {
  int wert;
  MyException(int i) {           // Konstruktor
    wert = i;
  };
  public int get_wert() {
    return wert;
  };
};
public class Main {
  public static void main (String[] args) {
    int x;
    try 
      {Main.unsafe_method(0);}
    catch (MyException e) {
      System.out.println("MyException mit wert = " + 
    e.get_wert());};
  };
  public static void unsafe_method(int i) throws MyException {
    if (i == 0)   {throw (new MyException (i));}
    else System.out.println("OK");
  };
};