Exceptions in Schleifen

[Alexander Erlich]

Guten Tag,

in einem online-Javakurs [
http://www.galileocomputing.de/openbook/javainsel2/java_070000.htm ] steht
folgendes:


import javax.swing.*;

public class ContinueInput
{
public static void main( String args[] )
{
int number = 0;

while ( true )
{
try
{
String s = JOptionPane.showInputDialog(
"Bitte Zahl eingeben" );
number = Integer.parseInt( s );

break;
}
catch ( NumberFormatException e )
{
System.out.println( "Das war keine Zahl!" );
}
}

System.out.println( "Danke für die Zahl " + number );
System.exit( 0 );
}
}Die gewählte Lösung ist einfach. Wir programmieren den gesamten Teil in
einer Endlosschleife. Geht die problematische Stelle ohne Fehler durch, so
beenden wir die Schleife mit break. Kommt es zu einer Ausnahme, dann wird
break nicht ausgeführt, und nach der Exception gelangen wir wieder in die
Endlosschleife.

--------------------------------

An dieser Stelle habe ich eine Frage: warum wird, wenn es zu einer Exception
kommt, wieder am Anfang der Schleife gelesen?



Vielen Dank im Voraus!

Gruß Alexander

[Michael Koenig]

On Wed, 25 Feb 2004 20:42:47 +0100, "Alexander Erlich"

Post by Alexander Erlich
An dieser Stelle habe ich eine Frage: warum wird, wenn es zu einer Exception
kommt, wieder am Anfang der Schleife gelesen?

weil in diesem Fall parseInt eine NumberFormatException wirft, diese
aber gleich in dem Catch-Block wieder gefangen wird. Wenn der
Catch-Block fertig abgearbeitet ist (System.out...), dann ist der
Schleifenblock mit einer "Runde" fertig und fängt wieder oben bei der
Bedingung an.

Bye, Michael

[Jens Körte]

Post by Alexander Erlich
An dieser Stelle habe ich eine Frage: warum wird, wenn es zu einer Exception
kommt, wieder am Anfang der Schleife gelesen?

Java bietet dir die Möglichkeit mit Hilfe von Exceptions auf Fehler
innerhalb des Programms (also während der Laufzeit) zu reagieren. Java
beendet das Programm jedoch nicht (wäre auch schwachsinning). Vielmehr
gibt Java dir die Möglichkeit den aufgetretenen Fehler zu behandeln.
Danach wird das Programm normal fortgesetzt. Deswegen muss die
Fehlerbehandlung derart durchgeführt werden, daß das Programm auch
weiterhin problemlos laufen kann.

Grüße
Jens

[Alexander Erlich]

Hallo Jens,

Post by Jens Körte
Danach wird das Programm normal fortgesetzt.

Aber das nurmale fortsetzen wäre doch das Weitergehen im Quelltext, und
nachdem bei parseInt die Exception ausgelöst wird, wäre es doch
folgerichtig, dass der Compiler wieder an diese Stelle, wo parseInt steht
(bzw. danach) springt, und in der nächsten Zeile steht break. Warum kommt es
aber nicht dazu? Die Schleife wird ja erneut durchlaufen, warum?

Danke sowohl an Jens als auch an Michael!

Gruß Alexander

[Jens Körte]

Post by Alexander Erlich
Aber das nurmale fortsetzen wäre doch das Weitergehen im Quelltext, und
nachdem bei parseInt die Exception ausgelöst wird, wäre es doch
folgerichtig, dass der Compiler wieder an diese Stelle, wo parseInt steht
(bzw. danach) springt, und in der nächsten Zeile steht break. Warum kommt es
aber nicht dazu? Die Schleife wird ja erneut durchlaufen, warum?

Ja, da habe ich wohl nicht richtig hingesehen... :-), aber so ganz
klar ist mir das auch nicht. Meine Erklärung ist folgende:

Nachdem ein Fehler auftritt wird sofort die Fehlerbehandlung durch den
catch-Block durchgeführt. Nachdem die Abarbeitung nun offensichtlich
fehl geschlagen ist, hat es auch keinen Sinn im try-block
weiterzumachen (würde ja zu falschen Ergebnissen führen), deswegen
wird nach dem try-catch-block weitergemacht, was einem erneuten
Durchlauf durch die Schleife entspricht.

Dies scheint mir die logische Abarbeitung zu sein.

Grüße
Jens

[Michael Koenig]

Post by Jens Körte
Ja, da habe ich wohl nicht richtig hingesehen... :-), aber so ganz
Nachdem ein Fehler auftritt wird sofort die Fehlerbehandlung durch den
catch-Block durchgeführt. Nachdem die Abarbeitung nun offensichtlich
fehl geschlagen ist, hat es auch keinen Sinn im try-block
weiterzumachen (würde ja zu falschen Ergebnissen führen), deswegen
wird nach dem try-catch-block weitergemacht, was einem erneuten
Durchlauf durch die Schleife entspricht.
Dies scheint mir die logische Abarbeitung zu sein.

um die Sache noch zu Ende zu bringen:

es könnte auch noch einen finally-Block geben, der auf jeden Fall
aufgerufen wird, egal ob es eine Exception gab oder nicht. Also z. B.

try
{
// tu hier was verbotenes
}
catch (NumberFormatException e)
{
// mach's hier wieder gut
}
finally
{
// und bereue
}

Der finally-Block ist vor allem dann interessant, wenn man - wenn eine
Exception geworfen wird - noch was tun möchte, aber deshalb trotzdem
nicht die Exception abfangen will.

Bye, Michael