# Verständnis Problem bei Aufgabe zu Exception Handling



## Ironzwerg (26. Aug 2008)

Hi zusammen,

ich bin neu hier und brauche ganz dringend Hilfe bei einer Aufgabe. Ich habe den ganzen Tag nach einer Lösung gesucht, jedoch keine gefunden. Ich hoffen hier kann man mir helfen.

Ich habe ein kleines Programm, in dem man über einen grafischen Eingabedialog einen int- und einen doule-Wert eingibt, der auch ausgegeben wird, wenn das konvertieren geklappt hat. Wenn das Konvertieren schief gegegangen ist, wird eine entsprechende Fehlermeldung ausgegeben. Wenn auf Abbrechen geklickt wird, erscheint ebenfalls eine entsprechende Fehlermeldung. Diese Fehlermeldung wird durch eine eigene Exception Klasse AbbruchException aufgerufen.

Genauere Beschreibung steht im Quelltext.

Hier ist der Quelltext zu der Testklasse:

```
package eindialogV2;
import javax.swing.JOptionPane;

/*####################################
 * Ein Test der Klasse EingabeDialogV2
 * Die Klasse wird über einen Verweis 
 * eingebunden
 * ###################################
 * BITTE BEACHTEN!
 * Sie müssen den Verweis zu der Klasse
 * erst löschen und anschließend neu
 * aufbauen.
 * Markieren Sie dazu den Eintrag für
 * den Verweis im Package Explorer und 
 * wählen Sie im Kontext-Menü die 
 * Funktion Build Path / Remove from 
 * BuildPath.
 * Danach können Sie den Verweis dann 
 * neu erstellen. 
 ####################################*/


public class EingabeDialogTestV2 {
	
	public static void main(String[] args) {
		int intWert = 0;
		double doubleWert = 0;
		
		//der Aufruf der Methode einlesen() mit einem int-Typen
		try {
				intWert = EingabeDialogV2.einlesen(intWert);
				JOptionPane.showMessageDialog(null,"Ihre Eingabe war " + intWert);
		}
		//die Behandlung der eigenen Exception
		catch (AbbruchException e) {
			JOptionPane.showMessageDialog(null,e.getMessage());
		}
		
		//der Aufruf der Methode einlesen() mit einem double-Typen
		try {
				doubleWert = EingabeDialogV2.einlesen(doubleWert);
				JOptionPane.showMessageDialog(null,"Ihre Eingabe war " + doubleWert);
		}
		//die Behandlung der eigenen Exception
		catch (AbbruchException e) {
			JOptionPane.showMessageDialog(null,e.getMessage());
		}
	}
}
```

Hier ist der Quelltext der eigentlichen Klasse

```
/***************************************************************
 * Eine Klasse für Eingaben über einen grafischen Dialog
 * **************************************************************
 * Das Einlesen erfolgt über eine überladene statische Funktion
 * einlesen()
 * Wenn das Einlesen abgebrochen wird, wird eine selbst
 * definierte Ausnahme ausgelöst
 * **************************************************************
 * Beschreibung der Methode einlesen()
 * 
 * Die Methode liest über die Methode lesen() einen Wert
 * ein und versucht, diesen Wert in den passenden Typ
 * umzuwandeln.
 * Die Ausnahme für den Abbruch wird an den Aufrufer
 * zurückgeliefert.
 * Die Ausnahme für eine ungültige Eingabe wird intern behandelt.
 * 
 * Parameter: 	wert für den Typ, der verarbeitet werden soll
 * Rückgabe: 	Der Wert, der umgewandelt wurde
 * 				Der Typ hängt dabei vom übergebenen Parameter ab
 * 
 * Die Methode ist drei Mal vorhanden (für int, float und double)
 * **************************************************************
 * Beschreibung der Methode lesen()
 * 
 * Die Methode wird zum Einlesen der Werte über den Dialog benutzt.
 * Sie löst außerdem die selbst definierte Ausnahme aus.
 * 
 * Parameter:	text als Zeichenkette für die Ausgabe im Dialog
 * Rückgabe:	Der eingelesene Wert als Zeichenkette
 * **************************************************************
 * */

//die Klasse befindet sich im Package eindialogV2
package eindialogV2;

//für den Eingabedialog
import javax.swing.JOptionPane;

public class EingabeDialogV2 {
	
	//die Hilfsmethode zum Einlesen der Daten über den Dialog
	//Beschreibung siehe oben
	private static String lesen(String text) throws AbbruchException {
		String eingabeTemp;
		eingabeTemp = JOptionPane.showInputDialog("Bitte geben Sie einen " + text + " Wert ein:");
		//Wenn die Eingabe abgebrochen wurde, wird eine selbst definierte Ausnahme ausgelöst
		if (eingabeTemp == null)
			throw new AbbruchException("Die Eingabe für " + text + " wurde abgebrochen");
		
		return (eingabeTemp);
	}
	
	//die überladene Methode einlesen() für den Typ int
	//Beschreibung siehe oben
	public static int einlesen(int wert) throws AbbruchException {
		int wertTemp = 0;
		String eingabeTemp;
		boolean gelungen = false;
		//solange Werte einlesen, bis die Konvertierung gelingt
		//der Abbruch wird in der Methoden lesen() behandelt
		while (gelungen == false) {
			eingabeTemp = lesen("int");
			try {
				wertTemp = Integer.parseInt(eingabeTemp);
				gelungen = true;
			}
			catch (NumberFormatException e) {
				JOptionPane.showMessageDialog(null,"Ihre Eingabe war nicht gültig. Bitte wiederholen...");
			}
		}
		
		return wertTemp;
	}
	
	//die überladene Methode einlesen() für den Typ double
	//Beschreibung siehe oben bzw. bei der Methode für den int-Typ
	public static double einlesen(double wert) throws AbbruchException {
		double wertTemp = 0;
		String eingabeTemp;
		boolean gelungen = false;
		while (gelungen == false) {
			eingabeTemp = lesen("double");
			try {
				wertTemp = Double.parseDouble(eingabeTemp);
				gelungen = true;
			}
			catch (NumberFormatException e) {
				JOptionPane.showMessageDialog(null,"Ihre Eingabe war nicht gültig. Bitte wiederholen...");
			}
		}
		
		return wertTemp;
	}
		
	//die überladene Methode einlesen() für den Typ float
	//Beschreibung siehe oben bzw. bei der Methode für den int-Typ
	public static float einlesen(float wert) throws AbbruchException {
		float wertTemp = 0F;
		boolean gelungen = false;
		String eingabeTemp;
		while (gelungen == false) {
			eingabeTemp = lesen("float");
			try {
				wertTemp = Float.parseFloat(eingabeTemp);
				gelungen = true;
			}
			catch (NumberFormatException e) {
				JOptionPane.showMessageDialog(null,"Ihre Eingabe war nicht gültig. Bitte wiederholen...");
			}
		}
		
		return wertTemp;
	}
}
```


Und hier der Quelltext der Exception Klasse:

```
package eindialogV2;
/* ###########################################################
 * Eine Klasse für die selbst definierte Ausnahme
 * ###########################################################
 * Sie erbt von der Klasse RuntimeException
 * und erstellt lediglich den Standard-Konstruktor und 
 * einen Konstruktor für die Übergabe der Meldung    
 #############################################################*/

public class AbbruchException extends Exception {
	
	/**
	 * die serialVersionUID wurde automatisch über Eclipse ergänzt
	 */
	private static final long serialVersionUID = 6034903258759501562L;

	//der Standard-Konstruktor
	AbbruchException() {
		super();
	}
	
	//der Konstruktor zur Übergabe einer Meldung
	//er ruft über super den Konstruktor der Basisklasse auf
	AbbruchException(String meldung) {
		super(meldung);
	}
}
```


Hier die Aufgabenstellung:

In der Klasse für die grafischen Eingabedialoge überprüfen wir durch den Vergleich einer Variablen mit dem Wert null, ob die Eingabe abgebrochen wurde.
Diese Konstruktion kann grundsätzlich auch durch eine Ausnahmebehandlung ersetzt werden. Welche Ausnahme käme dafür in Frage? Wie könnten Sie diese Ausnahme auslösen?

Ein kleiner Tipp:
Sehen Sie sich genau an, welchen Wert der Eingabedialog liefert, wenn die Eingabe abgebrochen wird. Benutzen Sie dazu gegebenenfalls auch den Debugger von Eclipse.


Ich weiß, dass der Eingabedialog null liefert, steht ja auch in der Variablen drin, wenn auch Abbrechen geklickt wird. Demnach würde eine NullPointerException in Frage kommen. Ich weiß auch, dass man eine Exception durch folgenden Befehl auslösen kann.

```
throw new NullPointerException("Die Eingabe für " + text + " wurde abgebrochen");
```

Für mich stellt sich nur die Frage, wie dies in diesem Fall aussehen würde. Also für mich ist die Frage nicht, wie ich eine Exception auslöse, sondern wo ich dies tun sollte.
Die Überprüfung der Variablen auf den Wert null fällt also weg, wie soll ich nun die Exception auslösen?

Ich hoffe ihr könnt mir helfen. Vielleicht habe ich auch nur einen Denkfehler.

Danke schon mal


Gruß

Ironzwerg


----------



## SlaterB (26. Aug 2008)

ich verstehe das so, dass du nicht selber die NullPointerException werfen,
sondern ohne Überprüfung mit der Variablen arbeiten sollst,
dann erzeugt der normale Ablauf eine NullPointerException,
diese kannst du irgendwo abfangen und dann die AbbruchException werfen,

das ist aber nur eine Interpretation, die vielleicht nicht richtig ist,
erschwerend kommt hinzu, dass im normalen Ablauf gar keine NullPointerException auftreten würde, sondern nur z.B.
java.lang.NumberFormatException: null

man müsste die Exception selber herausfordern durch einen zusätzlichen Aufruf eingabeTemp.toString();

alles ziemlich komisch, kann mir dazu keine klare Lösung vorstellen


----------



## Ironzwerg (26. Aug 2008)

Genau das ist auch mein Problem gewesen.
die NullPointerException tritt nur beim Konvertieren des double-Wertes auf, daher bin ich davon ausgegangen, dass ich die NullPointerException selber auslösen muss.


----------

