Exceptions

[Vokabulator]

Hallo!

Mein Wissensstand zu Exceptions/Fehlerbehandlung:

1. Den Fehler direkt behandeln

try { // möglicher Fehlercole } catch (Exception e) { // Behandlung} finally {  // optional}

Frage: Muss immer ein Exception-Objekt übergen werden? Oder kann es auch eine spezifischere Exception sein?

2. Aufgerufene Methode gibt Exception weiter:

public Methode() throws Exception { // Code }

--> Dann in der main-Methode:

try { //Methodenaufruf } catch {Exception e} { // Behandlung} finally {  // optional}

Frage: Was bedeutet "die Exception weitergeben"? Wenn ich in den catch-Teil was reinschreibe, dann wird die Exception ja auch an Ort und Stelle behandelt?!

3. main-Methode throws Exception: nur während der Entwicklungszeit sinnvoll

4. Eigene Exception:

public class MeineException extends Exception {

public MeineException() {

}

}

--> in der main-Methode

try { // code und irgendwann: throw new MeineException) {Exception e} { // Behandlung} finally {  // optional}

Frage: brauche ich das "throw new" nur im Zusammenhang mit eigenen Exceptions?

5. RuntimeExceptions und Errors muss man nicht explizit beheben, könnte man aber, wenn man weiß, was man tut.


Stimmt das soweit? Ich bin nämlich grad vollends verwirrt, weil meiner Ansicht nach überall was Anderes steht. Ich hab noch kein Buch und keine Webseite und kein YouTube-Tutorial gefunden, die einfach mal alle möglichkeiten schön systematisch auflisten und erklären...

Vielen Dank für Hilfen und Tipps!

[Christian Marquardt]

1. du wirst wohl einen try/catch nur dann einsetzen, wenn du eine Exception erwartest. Grundsätzlich kann es allg. sein, aber wie gesagt, man setzt es ja spezifiziert ein

2. die Exception wurde eben nicht am Ort es auftretens behandelt, sonden in der main-Methode. Sie wurde vom Ursprungsort weitergereicht

3. ist unverständlich

4. throw new ist immer dann einzusetzen, wenn du selbst eine werfen willst. Unabhängig davon, ob es eine eigene ist oder nicht

5. ist keine Frage

Ich hab noch kein Buch und keine Webseite und kein YouTube-Tutorial gefunden, die einfach mal alle möglichkeiten schön systematisch auflisten und erklären...

Hast du Internet?

http://openbook.galileocomputing.de/javainsel/

Wäre eine erste Anlaufstelle

[Vokabulator]

Wegen Java ist auch nur eine Insel. Das wäre eine erste Anlaufstelle, ist aber die mit Abstand verwirrendste. Keine Logik, keine Struktur... wer da durchblickt, Glückwünsche. Nix für Anfänger... da werden in einen Abschnitt zehn Aussagen gepackt, die alle wichtig sind, aber nur eine wird eklärt... jedes Mal wenn ich da reinschaue, weiß ich weniger, als vorher... Und glaub mir, ich hab nicht nur ein Java-Buch konsultiert oder eine PDf... oder eine Lern-DVD...

Zitat: Neben der rahmenbasierten Ausnahmebehandlung – dem »Einzäunen« von problematischen Blöcken durch einen try- und catch-Block – gibt es eine weitere Möglichkeit, auf Exceptions zu reagieren: das Weiterleiten an den Aufrufer.
--> Hier wird jetzt also zwischen rahmenbasierter Behandlung und Weiterleiten unterschieden... aber dass bei beiden Versionen (und eigentlich immer) der try/catch block steht, verwirrt ungemein... es liest sich nämlich so, als müsste man einmal den try/catch verwenden (den Rahmen) und ein anderes mal nicht.

Zu 1: Das heißt, die übergeben exception sollte so konkret wie möglich sein....

Zu 2: In der main methode steht aber nicht der Code, der den Fehler behandelt, oder? Der steht ja weiterhin im catch-Block... was genau ist dann das Weiterleiten?

Zu 3: Hab ich gelesen.... man sieht manchmal, dass die main-methode ein "throws..." hat... das sollte man wohl aber nur zur Entwicklungszeit machen, zu Testzwecken...

Zu 4: Danke für die klare Antwort

Zu 5: Stimmt, da fehlt das "?"... aber weiter unten steht ja "stimmt das alles?"

[Christian Marquardt]

ist aber die mit Abstand verwirrendste. Keine Logik, keine Struktur... wer da Durchblick, Glückwünsche. Nix für Anfänger.

Andere berichten genau das Gegenteil...

zu 2. Sicherlich steht der der in der main Methode.

2. Aufgerufene Methode gibt Exception weiter:

Code:

public Methode() throws Exception { // Code }
--> Dann in der main-Methode:

Code:

try { //Methodenaufruf } catch {Exception e} { // Behandlung} finally { // optional}

das war dein Beispiel

3. ja

[Vokabulator]

Folgendes Beispiel:

import java.text.DecimalFormat;
import java.text.ParseException;

public class NumberParser1 {
  public NumberParser1(String number) {
    DecimalFormat numberFormat = new DecimalFormat();
    try {
      Number xNumber = numberFormat.parse(number);
      double x = xNumber.doubleValue();
      System.out.println("Die eingegebene Zahl =  " + x);
    } catch(ParseException pEx) {
      System.out.println("Der eingegebene Parameter konnte nicht in eine Zahl umgewandelt werden.");
    }
  }

  public static void main(String[] args) {
    try {
      new NumberParser1(args[0]);
    } catch(ArrayIndexOutOfBoundsException aiobEx) {
      System.out.println("Das Programm erwartet eine Zahl als Eingabeparameter.");
    }
  }
}

Hier steht der try/catch-Block genau wie bei meinem Beispiel in der main-methode... in diesem Beispiel wird die Exception aber nicht weitergeleitet, sondern abgefangen... wo ist denn da der Unterschied zu meinem Beispiel??

Quelle: http://www.javakurs-online.de/javakurs09.html

[Christian Marquardt]

Das ist ein anderes Beispiel, als du dargestellt hast
Hier wird nirgendes eine Exception weitergereicht.

In der Methode NumberParser wird eine Exception vom Typ "ParseException" gefangen und behandelt (try/catch)
In der main-Methode wird eine Exception vom Typ "ArrayIndexOutOfBounds" gefangen und behandelt (try/catch)

Das folgende Beispiel zeigt eine Weiterreichung:

[highlight=java]
public class JavaApplication109
{
public static void main(String[] args)
{
JavaApplication109 j=new JavaApplication109();
try
{
j.methode1();
}
catch(FileNotFoundException ex)
{
//behandle Exception
}
}

public void methode1() throws FileNotFoundException
{
methode2();
}

public void methode2() throws FileNotFoundException
{
FileReader fr=new FileReader("ddd");
}

}



[/highlight]


Die Exception - und zwar DIESE - tritt in methode2 (durch den Filereader) auf. Sie wird über methode1 zur main-Methode weitergeleitet

[Vokabulator]

aaaahhh... okay... anderer Exception-Typ! Danke!

Danke auch für die anderen Antworten!!

[Vokabulator]

Noch mal ich:

String eingabe="17 Jahre";

int i;

try (

i = new Integer( eingabe).intValue ();
System.out.println( "Wert : " + i ) ;

} catch (NumberFormatException ne ) {

System.out.println( "Konvertierungsfehler" ) ;

}

Wenn im try-block was schief geht, wird eine Exception geworfen und im catch-block gefangen. Was mich verwirrt: Hier steht nirgends ein "throw". Wer löst die excepton aus? Wie entsteht das NumberFormatException -Objekt?

Und: sowohl wenn eine Methode eine exception selber wirft als auch wenn sie eine Exception weiterreicht, muss sie die "throws"-Klausel haben. Verstehe ich das richtig?

[Christian Marquardt]

1. Das throw (werfen) macht der Konstruktor der Klasse Integer selbst (über die parseInt Methode), wenn er den Wert nicht in einen int parsen kann. Er behandelt die Exception nicht selber mit einem try/catch, sondern leitet die an denjenigen weiter der den Konstruktor aufgerufen hat; nämlich dein Programm. Hier der Sourcecode des Konstuktors

[highlight=java] public Integer(String s) throws NumberFormatException {
this.value = parseInt(s, 10);
} [/highlight]

Hier der Code der parse-Methode, wo die Exception geworfen wird

[highlight=java] public static int parseInt(String s, int radix)
throws NumberFormatException
{
/*
* WARNING: This method may be invoked early during VM initialization
* before IntegerCache is initialized. Care must be taken to not use
* the valueOf method.
*/

if (s == null) {
throw new NumberFormatException("null");
}

if (radix < Character.MIN_RADIX) {
throw new NumberFormatException("radix " + radix +
" less than Character.MIN_RADIX");
}

if (radix > Character.MAX_RADIX) {
throw new NumberFormatException("radix " + radix +
" greater than Character.MAX_RADIX");
}

int result = 0;
boolean negative = false;
int i = 0, len = s.length();
int limit = -Integer.MAX_VALUE;
int multmin;
int digit;

if (len > 0) {
char firstChar = s.charAt(0);
if (firstChar < '0') { // Possible leading "+" or "-"
if (firstChar == '-') {
negative = true;
limit = Integer.MIN_VALUE;
} else if (firstChar != '+')
throw NumberFormatException.forInputString(s);

if (len == 1) // Cannot have lone "+" or "-"
throw NumberFormatException.forInputString(s);
i++;
}
multmin = limit / radix;
while (i < len) {
// Accumulating negatively avoids surprises near MAX_VALUE
digit = Character.digit(s.charAt(i++),radix);
if (digit < 0) {
throw NumberFormatException.forInputString(s);
}
if (result < multmin) {
throw NumberFormatException.forInputString(s);
}
result *= radix;
if (result < limit + digit) {
throw NumberFormatException.forInputString(s);
}
result -= digit;
}
} else {
throw NumberFormatException.forInputString(s);
}
return negative ? result : -result;
}

[/highlight]

2. ja