Java Fehlerbehandlung | Lernpfad Grundlagen

Java Grundlagen Schulung – Kursbezug

Dieses Kapitel ist Teil des Lernpfads zur Java Grundlagen Schulung. Termine & Buchung laufen über SemaTrain.de.

Hinweis: Beispiele sind didaktisch und nutzen Beispieldaten.

Ziel dieses Kapitels: Sie erkennen typische Fehlerquellen, fangen Exceptions gezielt ab, validieren Eingaben und geben verständliche Fehlermeldungen aus – statt dass das Programm „einfach abstürzt“.

Worum geht’s?

Was ist eine Exception – und warum ist sie hilfreicher als „irgendwas geht nicht“?
try/catch/finally: Fehler abfangen, sauber aufräumen.
throw: Eigene Fehlersituationen bewusst auslösen (Input-Validation).
Checked vs. unchecked (Praxisfokus: meist RuntimeException + klare Meldung).

Lehr-Lernziele

Nach diesem Kapitel können Sie …

LZ1: häufige Exception-Arten (z.B. NullPointerException, NumberFormatException) erkennen und deuten.
LZ2: mit try/catch robust reagieren und sinnvolle Fehltexte ausgeben.
LZ3: Eingaben validieren und bei Regelverstoß gezielt throw nutzen.
LZ4: verstehen, wofür finally bzw. „Cleanup“ gedacht ist (Ressourcen/Abschlusslogik).

Wie Ziele erreicht werden: Beispiele zeigen typische Exceptions (LZ1), danach try/catch + Validation (LZ2–LZ3). Das Mini-Projekt kombiniert alles zu einer robusten Konsolenlogik (LZ1–LZ4).

Typische Fehlerbilder (kurz)

null / falsche Referenz

Beispiel: NullPointerException vermeiden (Java)

public class NullPointerKurz {
  public static void main(String[] args) {
    String format = null; // kommt z.B. aus einer Eingabe
    // format.equals("Online") würde krachen:
    // NullPointerException
    System.out.println("Ist online? " + "Online".equals(format)); // sicherer
  }
}

Zahl parsen

Beispiel: NumberFormatException abfangen (Java)

public class NumberFormatKurz {
  public static void main(String[] args) {
    String eingabe = "drei";

    try {
      int tage = Integer.parseInt(eingabe);
      System.out.println("Tage: " + tage);
    } catch (NumberFormatException e) {
      System.out.println("Fehler: Bitte eine Zahl eingeben (z.B. 3)." );
    }
  }
}

try / catch / finally

Regel: so eng wie möglich try/catch, so klar wie möglich Fehltext.

Beispiel: try/catch/finally (didaktisch) (Java)

public class TryCatchFinallyBeispiel {
  public static void main(String[] args) {
    String preisText = "1490.00"; // Beispiel

    try {
      double preis = Double.parseDouble(preisText);
      System.out.println("Preis: " + preis + " €");

      // absichtliche Fehlerquelle (Beispiel)
      int dauerTage = 0;
      double tagespreis = preis / dauerTage; // Infinity, aber in anderen Fällen kann es knallen
      System.out.println("Tagespreis: " + tagespreis);

    } catch (NumberFormatException e) {
      System.out.println("Fehler: Preis muss eine Zahl sein.");

    } catch (Exception e) {
      // Fallback: nicht zu generisch in echten Projekten,
      // aber im Lernkontext ok als Sicherheitsnetz
      System.out.println("Unerwarteter Fehler: " + e.getClass().getSimpleName());

    } finally {
      System.out.println("(Cleanup) Vorgang abgeschlossen.");
    }
  }
}

Validieren und bewusst throw nutzen

Wenn Eingaben/Regeln verletzt werden: lieber früh abbrechen – mit klarer Aussage.

Beispiel: Input-Validation mit IllegalArgumentException (LZ3) (Java)

public class ValidierungMitThrow {

  static void pruefeKursDaten(String format, int dauerTage, double preis) {
    if (format == null || format.isBlank()) {
      throw new IllegalArgumentException("Format darf nicht leer sein.");
    }
    if (!format.equals("Online") && !format.equals("Praesenz")) {
      throw new IllegalArgumentException("Format muss Online oder Praesenz sein.");
    }
    if (dauerTage <= 0) {
      throw new IllegalArgumentException("Dauer muss > 0 sein.");
    }
    if (preis < 0) {
      throw new IllegalArgumentException("Preis darf nicht negativ sein.");
    }
  }

  public static void main(String[] args) {
    try {
      pruefeKursDaten("Online", 3, 1490.00);
      System.out.println("OK: Kursdaten sind plausibel (Beispiel).");

      // absichtlich kaputt:
      pruefeKursDaten("Online", 0, 1490.00);

    } catch (IllegalArgumentException e) {
      System.out.println("Eingabefehler: " + e.getMessage());
    }
  }
}

Optional: eigene Exception (für Fachlichkeit)

Für Kursregeln kann eine eigene Exception lesbarer sein. Im Alltag reicht oft IllegalArgumentException – hier als Lern-Option.

Optional: eigene RuntimeException für Kursregeln (Java)

class KursRegelException extends RuntimeException {
  KursRegelException(String message) {
    super(message);
  }
}

public class EigeneExceptionBeispiel {

  static void checkTeilnehmerZahl(int teilnehmer) {
    if (teilnehmer < 1) throw new KursRegelException("Teilnehmerzahl muss >= 1 sein.");
    if (teilnehmer > 25) throw new KursRegelException("Maximal 25 Teilnehmer (Beispielregel).");
  }

  public static void main(String[] args) {
    try {
      checkTeilnehmerZahl(30);
    } catch (KursRegelException e) {
      System.out.println("Regel verletzt: " + e.getMessage());
    }
  }
}

Praxisaufgabe (Mini)

Sie bauen eine robuste Kurs-Ausgabe: Eingabe prüfen, Fehler abfangen, sauber berichten.

Beitrag zu den Lehr-Lernzielen: LZ1 (Exceptions erkennen), LZ2 (try/catch), LZ3 (throw/Validation), LZ4 (finally/Cleanup).

Nehmen Sie Strings als „Eingabe“ (z.B. dauerText, preisText).
Parsen Sie Dauer/Preis in try (fangen Sie Parse-Fehler ab).
Validieren Sie Regeln (Dauer > 0, Preis >= 0, Format Online/Praesenz) und nutzen Sie throw.
Geben Sie am Ende eine klare Ausgabe oder eine klare Fehlermeldung aus.

Lösung anzeigen

Lösung: robust parsen + validieren + sauber melden (Java)

public class KursRobust {

  static void validate(String format, int dauerTage, double preis) {
    if (format == null || format.isBlank()) throw new IllegalArgumentException("Format fehlt.");
    if (!format.equals("Online") && !format.equals("Praesenz")) throw new IllegalArgumentException("Format muss Online oder Praesenz sein.");
    if (dauerTage <= 0) throw new IllegalArgumentException("Dauer muss > 0 sein.");
    if (preis < 0) throw new IllegalArgumentException("Preis darf nicht negativ sein.");
  }

  public static void main(String[] args) {

    // „Eingaben“ (Beispiel)
    String kursName = "Java Grundlagen Schulung";
    String format = "Online";
    String ort = "Hamburg";

    String dauerText = "3";
    String preisText = "1490.00";

    try {
      int dauerTage = Integer.parseInt(dauerText);
      double preis = Double.parseDouble(preisText);

      validate(format, dauerTage, preis);

      boolean istOnline = "Online".equals(format); // null-safe
      String ausgabeOrt = istOnline ? "remote" : ort;

      System.out.println("Kurs: " + kursName);
      System.out.println("Format: " + format + " | Ort: " + ausgabeOrt);
      System.out.println("Dauer: " + dauerTage + " Tage");
      System.out.println("Preis (Beispiel): " + preis + " €");

    } catch (NumberFormatException e) {
      System.out.println("Eingabefehler: Dauer/Preis müssen Zahlen sein.");

    } catch (IllegalArgumentException e) {
      System.out.println("Regelfehler: " + e.getMessage());

    } finally {
      System.out.println("(Cleanup) Verarbeitung beendet.");
    }
  }
}

Optional: typische Stolperfallen

catch zu breit: lieber spezifisch (NumberFormatException, IllegalArgumentException).
try zu groß: nur den riskanten Teil in try (Parsing/IO), Rest normal.
Null-Vergleich: \"Online\".equals(format) ist null-safe.
Fehlermeldungen: für Nutzer/Teilnehmer verständlich formulieren, nicht nur Stacktraces.

Kurz-Takeaways

LZ1: Exceptions liefern Hinweise auf Fehlerursachen (NPE, Parse-Fehler, etc.).
LZ2: try/catch macht Programme robust und Fehltexte verständlich.
LZ3: Regeln früh validieren und bei Verstoß throw nutzen.
LZ4: finally für Abschluss/Cleanup – läuft immer (auch bei Fehlern).

Fehlerbehandlung: Exceptions, try/catch, throw