# Eigene Ausnahmebehandlung



## thor_norsk (2. Feb 2022)

Guten Abend,
Wenn ich die Aufgabe richtig verstanden habe, soll ich die Aufgabe mit einer eigener try / catch -  Anweisung umprogrammieren ?

Aufgabe) In unserer Klasse für die grafischen Eingabedialog überprüfen wir durch den Vergleich einer Variablen mit dem wert null, ob die Eingabe abgebrochen wurde. Dieses Konstruktion kann grundsätzlich auch durch eine Ausnahmebehandlung ersetzt werden. Welche Ausnahme käme dafür infrage? Wie könnten Sie diese Ausnahme auslösen?
Ein kleiner Tipp: Sehen Sie sich genau an, welchen Wert der Eingabedialog liefert, wie die Eingabe abgebrochen wird. benutzen Sie dazu gegebenenfalls auch den Debugger von Eclipse.

[CODE lang="java" title="Ausnahmebehandlung"]public class EingabeDialog {
    //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);
    }[/CODE]

Mein Vorschlag:

[CODE lang="java" title="Einlsen"]package eingabedialog;
import javax.swing.JOptionPane;

public class Eingabe {

    private static String lesen(String text)  {

        String eingabeTemp;
        eingabeTemp = JOptionPane.showInputDialog("Bitte geben Sie einen " + text + " Wert ein:");
        boolean gelungen = false;

            while ( gelungen == false ) {   
                eingabeTemp = lesen (text);
                    try {
                        if (eingabeTemp != null)
                        gelungen = true;
                    }

                    catch (NumberFormatException e) {

                    JOptionPane.showMessageDialog(null,"Ihre Eingabe war nicht gültig. Bitte wiederholen...");
                }
            }

            return (eingabeTemp);
    }   
}[/CODE]

und die Testklasse:

[CODE lang="java" title="main - Klasse"]package eingabedialog;
import eingabedialog.Eingabe;
import javax.swing.JOptionPane;

public class EingabeTest {

    public static void main(String[] args) {

        String wert;

        // Aufruf der Methode einlesen() mit einem int-Typ!

        try {
                wert = Eingabe.lesen(wert);
                JOptionPane.showMessageDialog(null," Ihre Eingabe war"+wert);
            }

            // Behandlung der eigenen Exception

        catch (NumberFormatException e) {

            JOptionPane.showMessageDialog(null, e.getMessage()); 
        }
    }
}[/CODE]

In der main() - Klasse Zeile 14 macht Eclipse folgender Fehlermeldung: Die Methode lesen(String) aus dem Typ Eingabe ist nicht sichtbar (visible)

Danke!


----------



## Gelöschtes Mitglied 65838 (2. Feb 2022)

```
private static String lesen
```
ist sie auch ...


es kommt eine eingabe rein => wenn null dann exception

und du wirfst eine numberformat exception ... was hat die jetzt mit dem null zu tun?
gar nix...


sehr wahrscheinlich wirds dafür ne exception geben *hust*nullpointerexception*hust*

wie kannst du sie auflösen? naja der input ist ja ein string ... was hat ein string mehr als der wert null ... richtig die toString() methode da string von objekt extended und "null" nicht

also


```
wert= Eingabe.lesen();
wert.toString(); // wird eine nullpointer exception werfen falls null ... null hat keine toString() methode
```
jetzt hast immer noch dein private problem

dann mach nen umweg also wird dann


```
wert = Eingabe.umweg();

...
    ...
    ....
  
    public String umweg(){
     return Eingabe.lesen();
}
```

was JETZT noch sein könnte ist

du solltest nicht das lesen umschreiben sondern die Exception die beim lesen geworfen wird  behandeln

dann hast du einfach einen try catch block mit der "AbbruchException e" drin keine ahnung wies genau gemeint ist..mMn macht aber das erste mit dem null mehr sinn...


----------



## thor_norsk (2. Feb 2022)

Wäre laut Aufgabenstellung falsch, wenn ich Alles in der main - Klasse behandle? Also Eingabe in main , Ausnahme-Prüfung in main() und Ausgabe , Alles in main() ???? Wäre für mich einfacher als Anfänger


----------



## Gelöschtes Mitglied 65838 (2. Feb 2022)

du hast in der Lesen methode eine Ausnahme wenn ==null... dann wird die eigene Exception geworfen

```
Dieses Konstruktion kann grundsätzlich auch durch eine Ausnahmebehandlung ersetzt werden. Welche Ausnahme käme dafür infrage? Wie könnten Sie diese Ausnahme auslösen?
```
wie kannst du diese ersetzen? ... also in der Lesen methode diese solltest du umschreiben somit keine Exception mehr geworfen wird

dh

```
try{
    String wert = ....
    wert.toString() // falls null wird eine Exception kommen => um genau zu sein nullpointer
}catch ( NullPointerException e){
    throw new AbbruchException();
}
```
das wäre was ich abgeben würde...das if (... == null) soll durch ein try catch ersetzt werden

was hiermit getan wurde


----------



## thor_norsk (2. Feb 2022)

[CODE lang="java" title="JAVA"]private static String lesen(String text)  {

        String wert;   

        try{
                wert = JOptionPane.showInputDialog("Bitte geben Sie einen Wert ein");
                wert.toString();
            }
            catch (NullPointerException e){
                throw new AbbruchException();
            }
    }    [/CODE]

Wäre so richtig? Oder habe ich falsch verstanden?


----------



## Gelöschtes Mitglied 65838 (2. Feb 2022)

ja du hast einen fehler und den zeigt dir eclipse 

```
throw new AbbruchException();
```
wurde als eine Exception und nicht als eine Runtime Exception deklariert 

aber du wirfst sie dh => entweder catchen oder throwen ( hier gehts um die AbbruchException die nullpointer hast du ja gefangen )

in der Original methode wird sie gethrowed dh du musst sie auch noch throwen im methoden header
vergleich ma

```
private static String lesen(String text) throws AbbruchException {
```
... eine RuntimeException musst du nicht throwen aber eine RuntimeException macht hier auch keinen sinn 

warum?
falls falscher wert => reagiere ( theoretisch )

bei einer runtime exception 
falls falscher wert => möglichkeit zmu reagieren muss aber net sein


bei einer falschen eingabe sollte man aber im programm meistens reagieren ... ist nur aus logischer sicht beurteilt


----------



## thor_norsk (2. Feb 2022)

[CODE lang="java" title="AbbruchException"]package aufgabex;

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

    //der Standard-Konstruktor
    AbbruchException() {
        super();
    }

      AbbruchException(String meldung) {
        super(meldung);
    }
}[/CODE]

Und verbessert.

[CODE lang="java" title="WerteEinlesen"]package aufgabex;
import javax.swing.JOptionPane;

public class WerteEinlesen {

        private static String lesen (String text) throws AbbruchException {

        String wert;   

        try{
                wert = JOptionPane.showInputDialog("Bitte geben Sie einen Wert ein");
                wert.toString();
            }
            catch (NullPointerException e){
                throw new AbbruchException();
            }
        return (wert);
    }   
}
[/CODE]


----------



## thor_norsk (2. Feb 2022)

Die Vererbung ist eine tolle Sache, man braucht nicht vieles selber programmieren.


----------



## Gelöschtes Mitglied 65838 (2. Feb 2022)

was nicht "schick ist" ist dass das return am ende ist 

wie wäre es denn mit

```
private static String lesen (String text) throws AbbruchException {
    
    
        
        try{
                return JOptionPane.showInputDialog("Bitte geben Sie einen Wert ein").toString();
            }
            catch (NullPointerException e){
                throw new AbbruchException();
            }
    }
```

die formatierung is jetzt komplett am arsch 

...trotzdem wäre die if == null abfrage schöner gewesen... aber joa... blöde aufgabe wie meistens

weil jedes mal wenn du jetzt die lesen methode aufrufst musst du so einen selten dämlichen try catch block schreiben... anstatt dass die fehler behandlung in der methode bleibt aber joaaa... ka warum

außerdem ist ein try catch ressourcen aufwändiger um ein minimales minimü ... aber das sei mal dahingestellt


----------



## thor_norsk (2. Feb 2022)

Aber so wie ich formatiert habe ist auch richtig ? Wenn return am ende steht oder ?


----------



## Gelöschtes Mitglied 65838 (2. Feb 2022)

ja sieht nur blöd aus und verwirrt


meins sagt aus

```
return das ergebnis
oder
throw exception
```
deins sagt

```
setz wert
oder
throw exception
falls keine Exception
return wert
```
ist 1 mal ums eck gedacht... in einem code review könnte man es "annörgeln"

ob mans mit einer zwischen variable trotzdem macht ist davon nicht betroffen... kannst du nach lust und laune noch den String wert einbauen oder nich... kommt drauf an in welcher stimmung man ist


----------



## thor_norsk (2. Feb 2022)

OK. Dein Code ist kompakter aber besser.
Danke!


----------



## Gelöschtes Mitglied 65838 (2. Feb 2022)

```
private static String lesen (String text) throws AbbruchException {
    
    
        
        try{
                String wert = JOptionPane.showInputDialog("Bitte geben Sie einen Wert ein");
                return wert.toString();
            }
            catch (NullPointerException e){
                throw new AbbruchException();
            }
    }
```
geht natürlich auch


----------



## mihe7 (2. Feb 2022)

thor_norsk hat gesagt.:


> Die Vererbung ist eine tolle Sache, man braucht nicht vieles selber programmieren.


Vorsicht. Vererbung drückt ein Beziehung und damit eine (im Fall der Vererbung sogar sehr starke) Abhängigkeit zwischen Klassen aus. Dass man dadurch in der Regel Code spart, ist ein netter Nebeneffekt.


----------

