Analysieren den Programmablauf des folgenden Programms. Im Programm tritt eine Division durch Null auf. Diese Division löst eine ArtithmeticException aus.

Zur Hilfe sei die Klassenhierarchie der relevaten Ausnahmeklassen gegeben:

Markieren Sie im Programm die durchlaufenen Konsolenausgaben mit fortlaufenden Nummern. Beginnen Sie mit einer 1 bei der Ausgabe „main:before“.

public class Ausnahme {
   public static void main(String[] args) {
      int a = 5;   
      int b = 0;
      int c = 0;
System.out.println("main:before"); //Aufruf x
      c = divAussen(a, b);
      System.out.println("main:after"); //Aufruf x
   } // Ende von main

   static int divAussen(int a, int b) {
      int d;
      System.out.println("divAussen:beginn"); //Aufruf x
      try {
         d = 2 * divInnen(a, b);
      } catch (RuntimeException e) {
         System.out.println("divAussen: Division durch Null"); //Aufruf x
         d = -2;
      }
      System.out.println("divAussen:ende"); //Aufruf x
      return d;
   } // Ende von divAussen

   static int divInnen(int a, int b) {
      int d;
      System.out.println("divInnen:beginn"); //Aufruf x
      try {
         d = a / b; // Hier tritt eine Ausnahme auf
      } catch (IllegalArgumentException e) {
         System.out.println("divInnen: Division durch Null");
         d = -1;
      }
      System.out.println("divInnen:ende");
      return d;
   } // Ende von divInnen
} // Ende der Klasse

Die Antwort finden Sie auf der nächsten Seite (URL rechts unten klicken).

Was muss ein Entwickler bei einer „Checked Exception“ immer tun? Welche beiden Möglichkeiten hat er?

Die Antwort finden Sie auf der nächsten Seite (URL rechts unten klicken).

Antwort zur Frage 1: Exceptions (Ausnahmen)

public class Ausnahme {
   public static void main(String[] args) {
      int a = 5;   
      int b = 0;
      int c = 0;
       System.out.println("main:before"); //Aufruf 1
c = divAussen(a, b);
System.out.println("main:after"); //Aufruf 6
   } // Ende von main

   static int divAussen(int a, int b) {
      int d;
System.out.println("divAussen:beginn"); //Aufruf 2
      try {
         d = 2 * divInnen(a, b);
      } catch (RuntimeException e) {
System.out.println("divAussen: Division durch Null"); //Aufruf 4
         d = -2;
      }
System.out.println("divAussen:ende"); //Aufruf 5
      return d;
   } // Ende von divAussen

   static int divInnen(int a, int b) {
      int d;
System.out.println("divInnen:beginn"); //Aufruf 3
      try {
         d = a / b; // Hier tritt eine Ausnahme auf
      } catch (IllegalArgumentException e) {
         System.out.println("divInnen: Division durch Null");
         d = -1;
      }
      System.out.println("divInnen:ende");
      return d;
   } // Ende von divInnen
} // Ende der Klasse

Analysieren Sie den Programmablauf des folgenden Programms.

Im Programm tritt eine Division durch Null auf. Diese Division löst eine ArithmeticException aus.
Zur Hilfe sei die Klassenhierarchie der relevanten Ausnahmeklassen gegeben:

Markieren Sie im Programm die durchlaufenen Konsolenausgaben mit fortlaufenden, eingekreisten Nummern. Beginnen Sie mit einer 1 bei der Ausgabe „main:Anfang“.

package s1.block10;
public class Frage3 {
  
   public static void main(String[] args) {
      int a = 5; int b = 0;
      int c = 0;
      System.out.println("main:Anfang");
      c = divAussen(a, b);
      System.out.println("main:Ende");
   } // Ende von main
  
   static int divAussen(int a, int b) {
      int d;
      System.out.println("divAussen:Anfang");
      try {
        d = 2 * divInnen(a, b);
      } catch (ArithmeticException e) {
        System.out.println("divAussen: Division durch Null");
        d = -2;
      }
      System.out.println("divAussen:Ende"); 
      return d;
   } // Ende von divAussen
   
   static int divInnen(int a, int b) {
      int d;
      System.out.println("divInnen:Anfang");
      try {
         d = a / b; // Hier tritt eine Ausnahme auf
      } catch (IllegalArgumentException e) {
         System.out.println("divInnen: Division durch Null");
         d = -1;
      } catch (RuntimeException e) {
         System.out.println("divInnen: Division durch Null;" + " RuntimeException");
         d = -2;
      }
      System.out.println("divInnen:Ende");
      return d;
   } // Ende von divInnen
} // Ende der Klasse.

Die Antwort finden Sie hinter der nächsten Frage (URL rechts unten klicken).

Antwort zur Frage 2: Checked Exceptions

Der Entwickler muss die Ausnahme immer behandeln. Entweder behandelt er sie direkt oder er reicht sie aus der aktuellen Methode heraus. Das Herausreichen geschieht mit dem Schlüsselwort throws. In diesem Fall muss sich die äussere Methode um das Behandlen der Ausnahme kümmern.

Das folgende Javaprogramm wirft eine ArithmeticException wegen einer Division durch Null in der Methode divide().

Welche Konsolenausgaben erzeugt das Programm wegen seiner System.out.println() Aufrufe?

Das Beispielprogramm:

package s1.block10;
public class Frage4 {

   public static void main(String[] args) {
      int a = 5;
      int b = 0;
      int c = 0;
      System.out.println("main:before");
      c = doubleDiv(a, b);
      System.out.println("main:after");
   }

   static int doubleDiv(int a, int b) {
      int d;
      System.out.println("doubleDiv:before");
      d = 2 * divide(a, b);
      System.out.println("doubleDiv:after");
      return d;
   }

   static int divide(int a, int b) {
      int d;
      System.out.println("divide:before");
      d = a / b;
      System.out.println("divide:after");
      return b;
   }
}

Antwort zu Frage 3: Erkennen von Ausnahmen im Quellcode

public class Ausnahme {
  
   public static void main(String[] args) {
      int a = 5; int b = 0;
      int c = 0;
      System.out.println("main:Anfang"); // 1
      c = divAussen(a, b);
      System.out.println("main:Ende"); // 7
   } // Ende von main
  
   static int divAussen(int a, int b) {
      int d;
      System.out.println("divAussen:Anfang"); // 2
      try {
        d = 2 * divInnen(a, b);
      } catch (ArithmeticException e) {
        System.out.println("divAussen: Division durch Null");
        d = -2;
      }
      System.out.println("divAussen:Ende"); // 6
      return d;
   } // Ende von divAussen
   
   static int divInnen(int a, int b) {
      int d;
      System.out.println("divInnen:Anfang"); // 3
      try {
         d = a / b; // Hier tritt eine Ausnahme auf
      } catch (IllegalArgumentException e) {
         System.out.println("divInnen: Division durch Null");
         d = -1;
      } catch (RuntimeException e) {
         System.out.println("divInnen: Division durch Null;" + " RuntimeException"); // 4
         d = -2;
      }
      System.out.println("divInnen:Ende"); // 5
      return d;
   } // Ende von divInnen
} // Ende der Klasse.

Wann soll ein Entwickler eine Java-Assertion (Annahme, Zusicherung) verwenden und nicht eine Ausnahme (Exception)?

Geben Sie eine kurze Erklärung.

Die Antwort finden Sie hinter der nächsten Frage (URL rechts unten klicken).

Antwort zu Frage 4: Programmablauf bei Ausnahmen

main:before
doubleDiv:before
divide:before
Exception in thread "main" java.lang.ArithmeticException: / by zero
        at Kurs2.Exception.Frage1.divide(Frage1.java:25)
        at Kurs2.Exception.Frage1.doubleDiv(Frage1.java:17)
        at Kurs2.Exception.Frage1.main(Frage1.java:10)

In einer Methode A können

• checked Exceptions (Ausnahmen)
• unchecked Exceptions (Ausnahmen) und
• Assertions (Annahmen)

ausgelöst werden.

Ein Entwickler nutzt diese Methode A. Er kennt aber nicht die Implementierung der Methode A.

Fragen:

• Bei welcher der drei Konstrukte, kann er zur Laufzeit das Auslösen durch eine Konfiguration des Laufzeitsystems unterdrücken?
• Auf welche der drei Möglichkeiten muss er beim Aufruf, durch eine entsprechende Implementierung reagieren.
• Warum ist es nicht sinnvoll für alle Ausnahmen die in einer Methode auftreten können eine Behandlung zu implementier)? Nennen Sie eine Beispiel.

Die Antwort finden Sie hinter der nächsten Frage (URL rechts unten klicken).

Antwort zu Frage 5: Assertions versus Exceptions (Annahmen, Zusicherungen versus Ausnahmen)

Man verwendet Assertions zum Abfragen von Invarianten/Zuständen die im normalen Programmbetrieb nie vorkommen sollten
Man verwendet Ausnahmen/Exceptions für Zustände/Fehlerfälle die im normalen Progammbetrieb vorkommen können, jedoch eher selten sind.
Man verwendet Ausnahmen insbesondere für Sonderfälle die nicht unter dem direkten Einfluß des Entwicklers stehen. Zum Bsp.: Kein freier Hauptspeicher, keine Netzwerkverbindung.

Welche der beiden catch Blöcke werden im folgenden Programm durchlaufen? Welche Ausgaben erzeugt das folgende Programm?

Hinweis: Division durch 0 führen zu einer ArithmeticException.

package s1.block10;
public class Frage7

   public static void main(String[] args) {
     int a = 5;
     int b = 0;
     int c = 0;
     System.out.println("main:before");
     c = doubleDiv(a, b);
     System.out.println("main:after");
   }

   static int doubleDiv(int a, int b) {
     int d;
     System.out.println("doubleDiv:before");
     try {
        d = 2 * divide(a, b);
     }
     catch (ArithmeticException e) {
        System.out.println("doubleDiv: Division durch Null");
        d=-20;
     }
     System.out.println("doubleDiv:after");
     return d;
   }

   static int divide(int a, int b) {
      int d;
      System.out.println("divide:before");
      try {
         d = a / b;
      }
      catch (ArithmeticException e) {
         System.out.println("divide: Division durch Null");
         d = -1;
     }
     System.out.println("divide:after");
     return d;
  } // Ende main()
} // Ende Klasse

Die Antwort finden Sie hinter der nächsten Frage (URL rechts unten klicken).

Antwort zu Frage 6: Benutzung verschiedener Ausnahmen (Exception) und Zusicherungen, Annahmen (Assertions)

Bei welcher der drei Konstrukte, kann der Entwickler zur Laufzeit das Auslösen durch eine Konfiguration des Laufzeitsystems unterdrücken?

• Das Prüfen von Assertions kann man zur Laufzeit unterdrücken.

Auf welche der drei Möglichkeiten muss er beim Aufruf, durch eine entsprechende Implementierung reagieren.?

• Checked Exceptions

Warum ist es nicht sinnvoll für alle Ausnahmen die in einer Methode auftreten können eine Behandlung zu implementieren? Nennen Sie eine Beispiel.

• Es können in jedem Befehl Ausnahmen auftreten. Die Ausnahme kann durch ein externes Ereignis ausgelöst werden.(Netzwerkfehler, kein Hauptspeicher etc.)
• Beispiel: Eine Out-of-Memory-Ausnahme kann bei fast jedem Aufruf ausgelöst werden.

Hinweis: Die Implementierung der Frage 2 unterscheidet sich nur in den benutzten Ausnahmen von der Frage 2.52!

Welche der beiden catch Blöcke werden im folgenden Programm durchlaufen? Welche Ausgaben erzeugt das folgende Programm?

package s1.block10;

public class Frage7 {

   public static void main(String[] args) {
      int a = 5;
      int b = 0;
      int c = 0;
      System.out.println("main:before");
      c = doubleDiv(a, b);
      System.out.println("main:after");
   }

   static int doubleDiv(int a, int b) {
     int d;
     System.out.println("doubleDiv:before");
     try {
       d = 2 * divide(a, b);
   }
   catch (RuntimeException e) {
      System.out.println("doubleDiv: Division durch Null");
      d=-2;
   }
   System.out.println("doubleDiv:after");
   return d;
 }

   static int divide(int a, int b) {
      int d;
      System.out.println("divide:before");
      try {
         d = a / b;
      }
      catch (IllegalArgumentException e) {
         System.out.println("divide: Division durch Null");
         d = -1;
      }
      System.out.println("divide:after");
      return d;
   } // Ende main()
} // Ende der Klasse

Die Antwort finden Sie hinter der nächsten Frage (URL rechts unten klicken).

Antwort zu Frage 7: Programmablauf bei mehrern try-catch-Blöcken

Es wird nur der try-catch Block in divide() aufgerufen:

main:before
doubleDiv:before
divide:before
divide: Division durch Null
divide:after
doubleDiv:after
main:after

Hier werden in der Methode divide() mehrere Ausnahmebehandlungen (catch Blöcke) zu dem gegebenen try Block angeboten. Welche Blöcke werden ausgeführt und warum? Wie sieht die Konsolenausgabe aus?

package s1.block10;

public class Frage9{
   public static void main(String[] args) {
      int a = 5;
      int b = 0;
      int c = 0;
      System.out.println("main:before");
      c = doubleDiv(a, b);
     System.out.println("main:after");
   }

   static int doubleDiv(int a, int b) {
      int d;
      System.out.println("doubleDiv:before");
      try {
         d = 2 * divide(a, b);
      } catch (RuntimeException e) {
         System.out.println("doubleDiv: RuntimeException");
         d = -2;
     }
     System.out.println("doubleDiv:after");
     return d;
   }

   static int divide(int a, int b) {
      int d;
      System.out.println("divide:before");
      try {
         d = a / b;
      } catch (IllegalArgumentException e) {
         System.out.println("divide: IllegalArgumentException");
         d = -1;
     } catch (ArithmeticException e) {
        System.out.println("divide: ArithmeticException");
        d = -2;  
     } catch (RuntimeException e) {
        System.out.println("divide: RuntimeException");
        d = -3;
     }
     finally {
        System.out.println("divide: geschafft");
     }
     System.out.println("divide:after");
     return d;
   } // ende main()
} // Ende Klasse

Die Antwort finden Sie hinter der nächsten Frage (URL rechts unten klicken).

Antwort zu Frage 8: Programmablauf bei mehrern try-catch-Blöcken

Der try-catch Block in divide() wird nicht ausgeführt da keine IllegalArgumentException vorliegt. Erst der try-catch Block in der äusseren Methode doubleDiv() kommt zum Zug. Der letzte Dokumentationsaufruf in divide() wird daher nicht aufgerufen.

main:before
doubleDiv:before
divide:before
doubleDiv: Division durch Null
doubleDiv:after
main:after

In der folgenden Implementierung wird eine Ausnahme behandelt und dann eine neue erzeugt. Welche Blöcke werden ausgeführt und warum? Wie sieht die Konsolenausgabe aus?

Hinweis: Der Code der im Vergleich zur Frage 9 geändert wurde, ist fett markiert:

package s1.block10;

public class Frage10{
   public static void main(String[] args) {
     int a = 5;
     int b = 0;
     int c = 0;
     System.out.println("main:before");
     c = doubleDiv(a, b);
     System.out.println("main:after");
   }

static int doubleDiv(int a, int b) {
   int d;
   System.out.println("doubleDiv:before");
   try {
     d = 2 * divide(a, b);
   } catch (IllegalArgumentException e) {
       System.out.println("doubleDiv: IllegalArgumentException: "
           + e.getMessage());
       d = -2;
   }
   System.out.println("doubleDiv:after");
   return d;
}

static int divide(int a, int b) {
   int d;
   System.out.println("divide:before");
   try {
      d = a / b;
   } catch (IllegalArgumentException e) {
      System.out.println("divide: IllegalArgumentException");
      d = -1;
   } catch (ArithmeticException e) {
      System.out.println("divide: ArithmeticException");
      throw new IllegalArgumentException("Ich kann nicht mehr");
   } catch (RuntimeException e) {
      System.out.println("divide: RuntimeException");
      d = -3;
   }
   finally {
      System.out.println("divide: geschafft");
   }
   System.out.println("divide:after");
   return d;
   } // Ende main()
} // Ende der Klasse

Die Antwort finden Sie hinter der nächsten Frage (URL rechts unten klicken).

Antwort zu Frage 9: Programmablauf bei mehreren catch Blöcken

Der erste Catch Block in divide() wird nicht aufgerufen weil die entsprechende Ausnahme nicht vorliegt.

Der zweite Catch Block wird aufgerufen da die Ausnahme die passende ArithmeticExpetion ist.

Der dritte Catch Block wird nicht mehr aufgerufen obwohl eine ArtithmeticException auch eine RuntimeException ist. Die Ausnahme wurde schon im vorhergehenden Block behandelt.

Der finally Block wird immer durchlaufen.

main:before
doubleDiv:before
divide:before
divide: ArithmeticException
divide: geschafft
divide:after
doubleDiv:after
main:after

Bei der Behandlung von auftretenden Ausnahmen muss der Entwickler zwei Arten von Ausnahmen unterscheiden.

Nennen Sie die englischen Namen und charakterisieren Sie die beiden Arten:

• Erste Art (englischer Name): ?
  • Was muss der Entwickler hier beachten?
• Zweite Art (englischer Name): ?
  • Was muss der Entwickler hier beachten?

Die Antwort finden Sie hinter der nächsten Frage (URL rechts unten klicken).

Antwort zu Frage 10: Behandeln und Weiterreichen einer Ausnahme

Interessant: der finally Block wird trotz des Werfens der neuen Ausnahme durchlaufen:

main:before
doubleDiv:before
divide:before
divide: ArithmeticException
divide: geschafft
doubleDiv: IllegalArgumentException: Ich kann nicht mehr
doubleDiv:after
main:after

In Javacode können Ausnahmen auftreten. Man kann die Ausnahmen in Java mit einer besonderen Sprachkonstruktion behandeln. Sie umfasst das Programmieren von bis zu drei bestimmten Blöcken. Nennen und beschreiben Sie die drei Blöcke in der Reihenfolge des Auftretens. Vervollständigen Sie die Tabelle:

Die Antwort finden Sie hinter der nächsten Frage (URL rechts unten klicken).

Antwort zu Frage 11 Zwei Arten von Ausnahmen

• Erste Art (englischer Name): Unchecked Exceptions
  • Was muss der Entwickler hier beachten? Sie müssen nicht mit einem try-catch Block gefangen werden.
• Zweite Art (englischer Name): Checked Exceptions
  • Was muss der Entwickler hier beachten? Sie müssen immer mit einem try-catch Block ummantelt werden oder die Ausnahme muss im Methodenkopf deklariert werden
    

 Die Antwort zu Frage dieser Seite finden Sie viel weiter unten:

Antwort zu Frage 12: Syntax und Bedeutung von try-catch Blöcken