Fehlerbehandlung an einem Beispiel

[JavaLernen1]

Hallo, liebe Leute!

Ziel war es ein kleines Programm zu schreiben, das einen Weihnachtsbaum mit einer gewünschten Höhe ausgibt. Ein Baum der Höhe 12 soll zum Beispiel so aussehen:

Ich habe das, so denke ich jedenfalls, einigermaßen hinbekommen, hier mein Code:

import java.util.*;

public class XmasTree {

    static Scanner sc = new Scanner(System.in);

    public static void main(String[] args) {
        System.out.println("Hoehe des Baums eingeben: "); /* Erwünschte Höhe eingeben */
        int height = sc.nextInt();

        makeTree(height);

    }

    public static void makeTree(int height) {
        int maxWidth = (2 * height) - 1; /* Die breiteste Stelle des Baums */
        String root = makeString(height - 1, ' ') + makeString(1, '#') + makeString(height - 1, ' '); /* Der Stamm */

        /* Male alles außer Stamm: */
        for (int i = height; i > 0; i--) {
            String treeLevel = makeString(i - 1, ' ') + makeString(maxWidth - 2 * (i - 1), '*')
                    + makeString(i - 1, ' ');
            System.out.println(treeLevel);
        }
        System.out.println(root); /* Male zum Schluss noch den Stamm */
    }

    /**
     * Erzeuge einen String der Länge len, der nur aus dem Char c besteht
     *
     * @param len, c
     * @return
     */
    public static String makeString(int len, char c) {
        char[] cs = new char[len];
        Arrays.fill(cs, c);
        return new String(cs);

    }

}

Ich habe eine Methode geschrieben, die als Parameter die Länge und einen Char bekommt und dann einen String erzeugt mit der gewünschten Länge, und zwar nur aus dem vorgegebenen Zeichen bestehend, denn ich habe gelesen, dass es so eine Methode in Java nicht fertig implementiert gibt.

Nun würde ich gerne anhand dieses Beispiels lernen, wie man Fehlermeldungen berücksichtigen kann.
Mein Code liefert zum Beispiel einen Fehler, wenn der Benutzer die Höhe 0 eingibt:

Exception in thread "main" java.lang.NegativeArraySizeException: -1
    at XmasTree.makeString(XmasTree.java:37)
    at XmasTree.makeTree(XmasTree.java:19)
    at XmasTree.main(XmasTree.java:13)

Klar, denn in diesem Fall hat man einen negativen Arrayindex.

Mir ist nicht ganz klar, wie ich jetzt

throw

verwenden kann, um das abzufangen.
Auch die Benutzung von

try

die hier vielleicht angebracht wäre, ist mir nicht klar.

Vielleicht kann mir das jemand mal kurz erläutern? Aus den Lehrbüchern werde ich irgendwie nicht schlau.

Dankesehr, ein schönes Wochenende und viele Grüße!

 

[yfons123]

im besten fall drehst du es so hin dass die exceptions gar nicht passieren.. somit musst du sie auch nicht catchen oder werfen

 

[JavaLernen1]

im besten fall drehst du es so hin dass die exceptions gar nicht passieren.. somit musst du sie auch nicht catchen oder werfen

Das ist natürlich wahr. Aber vielleicht ist es gar nicht schlecht, wenn ich dieses Beispiel in der jetzigen Form mal verwende, um etwas über Fehlerbehandlung zu lernen. Und es macht ja allgemein wenig Sinn, hier eine nicht positive und nicht ganzzahlige Höhe einzugeben.

Daher würde es vielleicht Sinn machen, in Zeile 10 meines obiges Codes folgende Zeilen hinzuzufügen?

if (height <=0 || Integer.class.isInstance(height) == false)
            throw new IllegalArgumentException("Nur positive, ganzzahlige Hoehen erlaubt!");

 

[yfons123]

also es gibt ein paar ansätze

Exception

zb so wie du es gemacht hast

throw new IllegalArgumentException("Nur positive und ganzzahlige Hoehen erlaubt!");

aber jeder muss ein try catch benutzen wenn er deine Methode nutzt

oder eine eigene Exception bauen
bzw eien RuntimeException zu bauen.. somit nicht jeder der deinen code nutzt immer ein try catch machen muss

oder
du gibst logische werte zurück bei fehlerhafter eingabe zb
höhe -10 ==> das kann auch ein baum von höhe 0 sein

zb schau mal "ls" in linux an , du kannst kompletten schwachsinn als "filter" einstellen... wenn blödsinn gefiltert wird dann kommt halt auch nix raus..hat der andere pech gehabt

oder
Berichtigung der werte
zb aus höhe -10 einfach

int realeHoehe = Math.Abs(hoehe);

 

[Oneixee5]

Mir ist nicht ganz klar, wie ich jetzt Code:
throw
verwenden kann, um das abzufangen.

Die Verwendung erfolgt nach folgendem Prinzip:

public class Main {

    public static void main(final String[] args) {
        isPrime(0);
    }

    private static boolean isPrime(final int n) {
        if (n <= 1) {
            throw new ArithmeticException("parameter <= 1");
        }
        ...
        return true;
    }

}

Also idR. gibt es eine Bedingung, wird diese erfüllt, erzeugt man eine Exception. Das Schlüsselwort throws sorgt dann dafür das die Exception ausgelöst wird. ArithmeticException ist ja erst einmal nichts anderes als eine Objektinstanz.

Im konkreten Fall ist es so: "Eine Primzahl ist eine natürliche Zahl, die größer als 1 und ausschließlich durch sich selbst und durch 1 teilbar ist." - also wäre es falsch eine Zahl < 2 überhaupt dahingehend zu untersuchen.

 

[Oneixee5]

Auch die Benutzung von Code:
try
die hier vielleicht angebracht wäre, ist mir nicht klar.

Die Verwendung von try scheint genauso trivial, bringt aber gar nichts. try ermöglicht die Verwendung von catch - und nur ein Catch-Block kann eine Exception fangen. Wird eine Exception nicht aufgefangen ist das Programm zu ende. try bewirkt nur, dass die Verarbeitung nach dem Block in einem finally-Block vorgesetzt werden kann.

public class Main {

    public static void main(final String[] args) {
        try {
            isPrime(0);
        } catch (final ArithmeticException e) {
            System.out.println("Fehler: " + e.getMessage());
        }
    }

    public static boolean isPrime(final int n) {
        if (n <= 1) {
            throw new ArithmeticException("parameter <= 1");
        }
        // ...
        return true;
    }

}

Die richtige Verwendung von Exceptions ist kein einfaches Thema und teilweise kontrovers. Exceptions dienen nicht der Programmsteuerung sondern sind wirkliche Ausnahmen, z.B.: defekte Datenträger, Unterbrechung der Netzwerkverbindung, also Ausnahmen welche vom Programm nicht beeinflussbar sind. Fehleingaben eines Nutzers zu behandeln ist nicht der Sinn von Exceptions - wird aber oft gemacht und durch viele Entwickler toleriert.

 

[thecain]

aber jeder muss ein try catch benutzen wenn er deine Methode nutzt

IllegalArgumentException ist eine RumtimeException

 

[temi]

Nun würde ich gerne anhand dieses Beispiels lernen, wie man Fehlermeldungen berücksichtigen kann.

Es gilt eine Entscheidung zu treffen, wie man mit Fehlern umgehen möchte. Soll der Benutzer z. B. die Gelegenheit erhalten, seine Eingabe zu korrigieren?

In deinem Fall kann der Benutzer eine Zahl eingeben die kleiner als 1 ist oder er könnte gar keine Zahl eingeben. Das kannst du bereits prüfen, bevor deine Methode aufgerufen wird.

Oder deine Methode übernimmt die Prüfung und reagiert mit einer entsprechenden Ausnahme (Exception) darauf. In dem Fall würdest du versuchen (try) deine Methode mit den eingegebenen Parametern aufzurufen und auf einen möglichen Fehler entsprechend reagieren (catch). Ziel ist es fast immer, zu vermeiden, dass die (deine) Methode mit fehlerhaften Werten etwas ausführt, was zu einem ebenfalls fehlerhaftem Ergebins führt.

Grundsätzlich sollen Ausnahmen (exception) allerdings nicht zur Programmsteuerung verwendet werden. Man versucht sie also durch entsprechende vorherige Prüfungen zu vermeiden. Es gibt allerdings Ausnahmen (von der Regel), wie z. B. die Überprüfung, ob der Benutzer tatsächlich eine Zahl eingegeben hat. Das geht am sinnvollsten indem man die Umwandlung versucht (try) und entsprechend reagiert (catch).

 

[mihe7]

Um das Thema vielleicht mal kurz zusammenzufassen:

1. Exceptions werden von Methoden ausgelöst bzw. weitergereicht, wenn die Vorbedingungen vom Aufrufer nicht eingehalten wurden oder die Nachbedingungen nicht erfüllen werden können.
2. Java kennt checked und unchecked Exceptions. Checked Exceptions müssen in der Signatur der aulösenden/weiterreichenden Methode deklariert und vom Aufrufer behandelt (abgefangen oder weitergereicht) werden. Für unchecked Exceptions gilt das nicht; eine solche wird automatisch den Aufrufstapel entlang weitergereicht, bis sie (ggf. von der JVM) abgefangen wird.
3. Exceptions sind Ausnahmen und dienen in der Regel nicht dazu, den Programmablaufs des Aufrufers zu steuern. Ausnahme: wenn die Einhaltung der Vorbedingungen vor dem Aufruf der Methode nicht oder nur mit unverhältnismäßig großem Aufwand geprüft werden kann, lässt man es auf die Exception ankommen.

Beispiele:

/** Berechnet die Fakultät einer natürlichen Zahl.
 *
 * @param n  natürliche Zahl inkl. 0.
 * @return Fakultät von n.
 * @throws IllegalArgumentException  falls n negativ ist. 
 * @throws ArithmeticExceptions  falls das Ergebnis zu groß ist.
 */
public long fak(int n) {
    if (n < 0) {
        throw new IllegalArgumentException(n + " ist keine natürliche Zahl");
    }
    int current = 1;
    long result = 1;
    do {
        result = StrictMath.multiplyExact(result, current);
        current++;
    } while (current <= n);

    return result;
}

Hier wird eine IllegalArgumentException ausgelöst, wenn die Vorbedingung (n ist natürliche Zahl) vom Aufrufer nicht eingehalten wurde.

Außerdem hat der Entwickler das größte mögliche n nicht im Vorfeld ausgerechnet. Dann hätte er als Vorbedingung bereits schreiben können, dass 0 <= n <= 20 gelten muss. Stattdessen wird eine ArithmeticException ausgelöst, wenn die Methode die Nachbedingung nicht erfüllen kann, weil das Ergebnis nicht mehr mit dem Datentyp long darstellbar ist. Diese Exception wird von StrictMath.multiplyExact geworfen, in der Methode fak nicht behandelt und damit einfach weitergereicht. Sowohl IllegalArgumentException als auch ArithmeticException sind unchecked Exceptions.

Der Aufrufer kann Exceptions abfangen, ganz unabhängig davon, ob es sich um checked oder unchecked Exceptions handelt:

try {
    fak(n);
} catch (IllegalArgumentException ex) {
    System.out.println("Bitte keine negativen Zahlen eingeben!");
} catch (ArithmeticException ex) {
    System.out.pritnln("Bitte eine kleinere Zahl eingeben.");
}

Bei der Frage, ob man eine checked oder eine unchecked Exception werfen soll, müssen wir Punkt 1 oben etwas weiter bzw. anders aufschlüsseln und die Frage stellen, warum eine Methode die Nachbedingung nicht erfüllen kann. Hier gibt es im Wesentlichen zwei Gründe: a) Ausnahmefall in der Geschäftslogik oder b) Fehler/Störung.

Im Fall a) handelt es sich eher um einen alternativen Rückgabewert, der vom Aufrufer erwartet und behandelt werden muss, wenn er auch nur sehr selten auftritt. Bei b) ist es genau anders, da dieser Fall vom Aufrufer erst gar nicht erwartet wird. Daher: checked Exception im Fall a), unchecked Exception im Fall b). Natürlich sind das eher Daumenregeln, und die Grenzen nicht immer ganz klar.

Beispiel: meine Kaffeemaschine wirft mir ständig irgendwelche Exceptions entgegen. Mal sind zu wenig Bohnen im Behälter, mal ist der Tresterbehälter voll und dann fehlt natürlich Wasser. Das sind typische checked Exceptions. Es sind Ausnahmen (ok, bei meinem Verbrauch eher die Regel), als Anwender muss ich damit rechnen (natürlich könnte ich das vorher überprüfen, aber wer will das schon?) und entsprechend behandeln: der NoBeansException entgegne ich z. B., indem ich prüfe, ob der Bohnenbehälter leer ist und ggf. Bohnen nachfülle.

Dagegen wäre eine defekte Elektronik ein echter Fehler, mit dem ich als Anwender nicht rechne: unchecked Exception. Eventuell zeigt mir das die Maschine noch am Display an, aber behandeln kann ich diese Ausnahme selbst nicht. Das geht dann eine "Stufe weiter" zum Hersteller.