Zum Inhalt springen

Exceptions

Seit dem ersten Tag begleiten uns Exceptions: Die InputMismatchException, wenn jemand bei nextInt() Buchstaben tippt. Die ArrayIndexOutOfBoundsException. Die NullPointerException. Und seit dem Kapitel Kapselung lösen wir selbst welche aus. Bisher war jede Exception das Ende des Programms. Jetzt lernen wir, darauf zu reagieren.

  • eine Fehlermeldung mit Stack Trace lesen
  • Exceptions mit try und catch abfangen und behandeln
  • Ressourcen wie einen Scanner mit try-with-resources sicher schließen
  • geprüfte und ungeprüfte Exceptions unterscheiden
  • eine eigene Exception schreiben und auslösen

Ausgangsstand für 15-bank

⤓ bank-exceptions.zip herunterladen

Wer die letzte Stufe nicht fertig hat, startet hiermit: Rechtsklick auf das Projekt15-bank → Import… → General → Archive File → die ZIP-Datei wählen →Finish. Vorhandene Dateien werden dabei – nach Rückfrage – überschrieben.

Enthält: Betrag.java, Buchung.java, Kunde.java, Konto.java, Kontostatus.java, GiroKonto.java, SparKonto.java, Verzinsbar.java, Festgeld.java, Zinslauf.java, Bank.java, Bankdemo.java, BetragTest.java, BuchungTest.java, KontoTest.java, GiroKontoTest.java, SparKontoTest.java, BankTest.java, ZinslaufTest.java

So sieht es aus, wenn der Bankautomat aus diesem Kapitel – noch ohne Fehlerbehandlung – statt einer Zahl viel bekommt:

Terminal-Fenster
Exception in thread "main" java.util.InputMismatchException
at java.base/java.util.Scanner.throwFor(Scanner.java:977)
at java.base/java.util.Scanner.next(Scanner.java:1632)
at java.base/java.util.Scanner.nextInt(Scanner.java:2297)
at java.base/java.util.Scanner.nextInt(Scanner.java:2251)
at de.drv.bank.Bankautomat.liesGanzzahl(Bankautomat.java:33)
at de.drv.bank.Bankautomat.main(Bankautomat.java:17)
  • Die erste Zeile nennt die Art der Exception – und, wenn vorhanden, eine Meldung.
  • Darunter steht der Stack Trace: der Weg, auf dem das Programm an die Fehlerstelle kam. Oben die Stelle, an der die Exception entstand, ganz unten main. Von unten gelesen: main hat in Zeile 17 liesGanzzahl aufgerufen, und dort hat Zeile 33 nextInt() aufgerufen.
  • Die Zeilen aus der Standardbibliothek (java.base/…) helfen selten. Suche die erste Zeile aus deinem eigenen Code – hier Bankautomat.java:33. In Eclipse lässt sie sich in der Console anklicken.
  • Manchmal folgt ein Abschnitt Caused by: – dann wurde eine Exception durch eine andere ausgelöst. Die eigentliche Ursache steht meist ganz unten.

Endlich lösen wir das Problem vom ersten Tag: Ein Programm soll bei einer falschen Eingabe nicht abstürzen, sondern noch einmal fragen.

Bankautomat.java (Ausschnitt)
public static int liesGanzzahl(Scanner scanner, String frage) {
while (true) {
System.out.print(frage);
try {
int zahl = scanner.nextInt();
scanner.nextLine();
return zahl;
} catch (InputMismatchException e) {
System.out.println("Bitte eine ganze Zahl eingeben.");
scanner.nextLine();
}
}
}
Terminal-Fenster
Wie viel Euro auf das Sparkonto überweisen? viel
Bitte eine ganze Zahl eingeben.
Wie viel Euro auf das Sparkonto überweisen? 100
  • Der Code im try-Block wird ganz normal ausgeführt.
  • Tritt darin eine InputMismatchException auf, springt die Ausführung sofort in den passenden catch-Block. Der Rest des try-Blocks wird übersprungen.
  • Danach geht es nach dem catch-Block weiter – hier mit dem nächsten Schleifendurchlauf.
  • e ist das Exception-Objekt. Es enthält unter anderem die Meldung: e.getMessage().

while (true) mit return mittendrin ist hier übrigens die klarste Form: Die Schleife endet genau dann, wenn eine gültige Zahl gelesen wurde.

Ein try kann mehrere catch-Blöcke haben – für jede Art Fehler die passende Reaktion:

try {
// …
} catch (KontoNichtGedecktException e) {
// …
} catch (IllegalArgumentException e) {
// …
}

Geprüft wird von oben nach unten; es läuft nur der erste passende Block. Deshalb gehören speziellere Exceptions nach oben. Fängt ein früherer Block schon eine allgemeinere Art ab, meldet Eclipse: Unreachable catch block for InputMismatchException. It is already handled by the catch block for Exception.

Sollen mehrere Arten gleich behandelt werden, geht es auch kürzer: catch (IllegalArgumentException | IllegalStateException e).

Seit Tag 1 schließen wir den Scanner mit scanner.close() – ganz am Ende. Was, wenn vorher eine Exception das Programm verlässt? Dann wird close() nie erreicht. Dafür gibt es try-with-resources:

Bankautomat.java (Ausschnitt)
try (Scanner scanner = new Scanner(System.in)) {
int euro = liesGanzzahl(scanner, "Wie viel Euro auf das Sparkonto überweisen? ");
// …
}

Was in den runden Klammern nach try erzeugt wird, schließt Java automatisch am Ende des Blocks – egal, ob er normal endet oder durch eine Exception. Die Eclipse-Warnung Resource leak: ‘scanner’ is never closed verschwindet. Ab jetzt ist das die übliche Form für alles, was geschlossen werden muss: Scanner, Dateien, Datenbankverbindungen.

Alle Exceptions sind Objekte und stammen von der Klasse Throwable ab:

Throwable
├── Error schwere Fehler der JVM – nicht abfangen
│ └── StackOverflowError, OutOfMemoryError, …
└── Exception geprüft
├── IOException, … geprüft
└── RuntimeException ungeprüft
└── IllegalArgumentException, IllegalStateException,
NullPointerException, InputMismatchException, …
ungeprüft (unchecked) geprüft (checked)
erbt von RuntimeException Exception, aber nicht RuntimeException
typischer Anlass ein Programmierfehler: null, falscher Index, ungültiges Argument etwas, das trotz richtigem Code schiefgehen kann: Datei fehlt, Netz weg
Compiler verlangt Behandlung nein ja

Bei einer geprüften Exception besteht der Compiler darauf, dass du dich entscheidest: Entweder du fängst sie mit catch ab – oder du gibst sie mit throws an deinen Aufrufer weiter. Tust du beides nicht, meldet Eclipse: Unhandled exception type IOException.

try {
String inhalt = Files.readString(Path.of("kunden.txt"));
System.out.println(inhalt);
} catch (IOException e) {
System.out.println("Datei nicht lesbar: " + e);
}
Terminal-Fenster
Datei nicht lesbar: java.nio.file.NoSuchFileException: kunden.txt

Mit Dateien beschäftigen wir uns in der zweiten Woche ausführlich. Hier zeigt das Beispiel nur: Bei einer fehlenden Datei hilft kein besserer Code – das Programm muss damit rechnen. Deshalb ist IOException geprüft.

ueberweisen lieferte bisher false, wenn das Konto nicht gedeckt war. Das ist leicht zu übersehen: Wer den Rückgabewert nicht prüft, glaubt, das Geld sei unterwegs. Für eine Überweisung ist das zu riskant. Wir machen daraus eine geprüfte Exception – dann muss jeder Aufrufer reagieren.

KontoNichtGedecktException.java
package de.drv.bank;
public class KontoNichtGedecktException extends Exception {
private static final long serialVersionUID = 1L;
private final Betrag fehlbetrag;
public KontoNichtGedecktException(Konto konto, Betrag betrag) {
super("Konto " + konto.getKontokennung() + " ist für " + betrag + " nicht gedeckt.");
this.fehlbetrag = betrag.minus(konto.getVerfuegbarerBetrag());
}
public Betrag getFehlbetrag() {
return fehlbetrag;
}
}
  • Eine eigene Exception ist eine ganz normale Klasse, die von Exception (geprüft) oder RuntimeException (ungeprüft) erbt.
  • super(…) übergibt die Meldung – sie erscheint später bei getMessage() und in der Fehlerausgabe.
  • Eine Exception darf eigene Daten tragen – hier den Fehlbetrag. So kann der Aufrufer gezielt reagieren („Es fehlen 200,00 €“).
  • serialVersionUID: Ohne diese Zeile warnt Eclipse – The serializable class … does not declare a static final serialVersionUID field. Was es damit auf sich hat, ist für uns nicht wichtig; die Zeile gehört einfach in jede eigene Exception.
Konto.java (Ausschnitt)
public final void ueberweisen(Konto ziel, Betrag betrag) throws KontoNichtGedecktException {
if (!ziel.status.isEinzahlungErlaubt()) {
throw new IllegalStateException("Das Zielkonto nimmt keine Zahlungen an – Konto "
+ ziel.status.getBezeichnung() + ".");
}
if (!abheben(betrag)) {
throw new KontoNichtGedecktException(this, betrag);
}
ziel.einzahlen(betrag);
}
  • throws KontoNichtGedecktException im Methodenkopf kündigt an: Diese Methode kann diese geprüfte Exception auslösen.
  • Statt return false steht jetzt throw new ….
  • Ein Aufruf ohne try/catch meldet Eclipse jetzt: Unhandled exception type KontoNichtGedecktException. Übersehen ist nicht mehr möglich.

Der Bankautomat behandelt beide Fälle:

Bankautomat.java (Ausschnitt)
try {
giro.ueberweisen(spar, Betrag.euro(euro));
System.out.println("Überwiesen. " + giro);
} catch (KontoNichtGedecktException e) {
System.out.println("Nicht möglich: " + e.getMessage());
System.out.println("Es fehlen " + e.getFehlbetrag() + ".");
} catch (IllegalArgumentException e) {
System.out.println("Ungültiger Betrag: " + e.getMessage());
}
Terminal-Fenster
Girokonto 12345678/1001 (Anna Muster, aktiv): 100,00 €, Dispo 200,00 €
Wie viel Euro auf das Sparkonto überweisen? 500
Nicht möglich: Konto 12345678/1001 ist für 500,00 € nicht gedeckt.
Es fehlen 200,00 €.
KontoTest.java (Ausschnitt)
@Test
@DisplayName("Überweisen ohne Deckung ändert keines der Konten")
void ueberweisenOhneDeckung() {
Konto von = konto(Betrag.euro(10));
Konto nach = konto();
KontoNichtGedecktException fehler = assertThrows(KontoNichtGedecktException.class,
() -> von.ueberweisen(nach, Betrag.euro(30)));
assertEquals(Betrag.euro(20), fehler.getFehlbetrag());
assertEquals(Betrag.euro(10), von.getKontostand());
assertEquals(Betrag.NULL, nach.getKontostand());
}

assertThrows liefert die aufgefangene Exception zurück – so lässt sich auch ihr Inhalt prüfen. Tests, die eine erfolgreiche Überweisung prüfen, geben die geprüfte Exception mit throws KontoNichtGedecktException einfach weiter: Tritt sie auf, schlägt der Test fehl.

Tu das Lass das
eine bestimmte Exception fangen: catch (InputMismatchException e) catch (Exception e) für alles – dann fängst du auch Fehler, mit denen du nicht gerechnet hast
reagieren: Hinweis ausgeben, neu fragen, weitergeben einen leeren catch-Block – der Fehler verschwindet spurlos
Meldungen, die sagen, was nicht ging und warum throw new RuntimeException("Fehler")
Exceptions für Ausnahmen Exceptions statt einer einfachen if-Abfrage – etwa um eine Schleife zu beenden

Und: Fange eine Exception nur dort, wo du sinnvoll reagieren kannst. Kann eine Methode nichts Vernünftiges tun, gibt sie die Exception weiter – mit throws bei geprüften, ganz von selbst bei ungeprüften.

Meldung bzw. Symptom Ursache
Unhandled exception type … geprüfte Exception weder gefangen noch mit throws weitergegeben
Unreachable catch block for … It is already handled by the catch block for … allgemeinerer catch-Block steht vor dem spezielleren
Unreachable catch block for … This exception is never thrown from the try statement body Im try kann diese geprüfte Exception gar nicht auftreten
The serializable class … does not declare a static final serialVersionUID … (Warnung) serialVersionUID in der eigenen Exception fehlt
Resource leak: … is never closed (Warnung) try-with-resources benutzen
Endlosschleife beim Einlesen falsche Eingabe im catch nicht mit nextLine() verworfen
  1. Schreibe KontoNichtGedecktException und stelle ueberweisen darauf um. Passe die Tests an – ohne die erwarteten Kontostände zu ändern.

    Lösung
    Konto.java
    package de.drv.bank;
    import java.time.LocalDate;
    public abstract class Konto {
    public static final String BANKLEITZAHL = "12345678";
    private static int naechsteNummer = 1001;
    private final int kontonummer;
    private final Kunde inhaber;
    private final LocalDate eroeffnetAm;
    private Betrag kontostand;
    private Kontostatus status;
    public Konto(Kunde inhaber) {
    if (inhaber == null) {
    throw new IllegalArgumentException("Ein Konto braucht einen Inhaber.");
    }
    this.kontonummer = naechsteNummer;
    naechsteNummer++;
    this.inhaber = inhaber;
    this.eroeffnetAm = LocalDate.now();
    this.kontostand = Betrag.NULL;
    this.status = Kontostatus.AKTIV;
    }
    public int getKontonummer() {
    return kontonummer;
    }
    public Kunde getInhaber() {
    return inhaber;
    }
    public LocalDate getEroeffnetAm() {
    return eroeffnetAm;
    }
    public Betrag getKontostand() {
    return kontostand;
    }
    public abstract String getKontoart();
    public abstract void monatsabschluss();
    public Betrag getVerfuegbarerBetrag() {
    return kontostand;
    }
    public Kontostatus getStatus() {
    return status;
    }
    public void sperren() {
    if (status != Kontostatus.AKTIV) {
    throw new IllegalStateException("Nur ein aktives Konto kann gesperrt werden.");
    }
    status = Kontostatus.GESPERRT;
    }
    public void entsperren() {
    if (status != Kontostatus.GESPERRT) {
    throw new IllegalStateException("Das Konto ist nicht gesperrt.");
    }
    status = Kontostatus.AKTIV;
    }
    public void kuendigen() {
    if (status == Kontostatus.GEKUENDIGT) {
    throw new IllegalStateException("Das Konto ist bereits gekündigt.");
    }
    if (!kontostand.equals(Betrag.NULL)) {
    throw new IllegalStateException("Nur ein leeres Konto kann gekündigt werden.");
    }
    status = Kontostatus.GEKUENDIGT;
    }
    public final void einzahlen(Betrag betrag) {
    pruefePositiv(betrag);
    if (!status.isEinzahlungErlaubt()) {
    throw new IllegalStateException("Keine Einzahlung möglich – Konto " + status.getBezeichnung() + ".");
    }
    kontostand = kontostand.plus(betrag);
    }
    public final boolean abheben(Betrag betrag) {
    pruefePositiv(betrag);
    if (!status.isAuszahlungErlaubt()) {
    throw new IllegalStateException("Keine Auszahlung möglich – Konto " + status.getBezeichnung() + ".");
    }
    if (betrag.istGroesserAls(getVerfuegbarerBetrag())) {
    return false;
    }
    kontostand = kontostand.minus(betrag);
    return true;
    }
    public final void ueberweisen(Konto ziel, Betrag betrag) throws KontoNichtGedecktException {
    if (!ziel.status.isEinzahlungErlaubt()) {
    throw new IllegalStateException("Das Zielkonto nimmt keine Zahlungen an – Konto "
    + ziel.status.getBezeichnung() + ".");
    }
    if (!abheben(betrag)) {
    throw new KontoNichtGedecktException(this, betrag);
    }
    ziel.einzahlen(betrag);
    }
    protected void belasten(Betrag betrag) {
    pruefePositiv(betrag);
    kontostand = kontostand.minus(betrag);
    }
    public String getKontokennung() {
    return BANKLEITZAHL + "/" + kontonummer;
    }
    @Override
    public String toString() {
    return getKontoart() + " " + getKontokennung() + " (" + inhaber.getName() + ", " + status.getBezeichnung() + "): "
    + kontostand;
    }
    @Override
    public boolean equals(Object obj) {
    if (this == obj) {
    return true;
    }
    if (!(obj instanceof Konto anderes)) {
    return false;
    }
    return kontonummer == anderes.kontonummer;
    }
    @Override
    public int hashCode() {
    return Integer.hashCode(kontonummer);
    }
    private static void pruefePositiv(Betrag betrag) {
    if (betrag == null || !betrag.istGroesserAls(Betrag.NULL)) {
    throw new IllegalArgumentException("Der Betrag muss größer als 0 sein: " + betrag);
    }
    }
    }
    Lösung
    KontoTest.java
    package de.drv.bank;
    import static org.junit.jupiter.api.Assertions.assertEquals;
    import static org.junit.jupiter.api.Assertions.assertFalse;
    import static org.junit.jupiter.api.Assertions.assertNotEquals;
    import static org.junit.jupiter.api.Assertions.assertThrows;
    import static org.junit.jupiter.api.Assertions.assertTrue;
    import java.time.LocalDate;
    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Test;
    class KontoTest {
    private final Kunde anna = new Kunde("Anna Muster", LocalDate.of(2004, 3, 12));
    /** Konto ist abstrakt – getestet wird mit einem Girokonto ohne Dispo, das sich wie ein Konto verhält. */
    private Konto konto() {
    return new GiroKonto(anna, Betrag.NULL);
    }
    private Konto konto(Betrag startguthaben) {
    Konto konto = konto();
    konto.einzahlen(startguthaben);
    return konto;
    }
    @Test
    @DisplayName("Ein neues Konto ist leer")
    void neuesKontoIstLeer() {
    assertEquals(Betrag.NULL, konto().getKontostand());
    }
    @Test
    @DisplayName("Startguthaben wird gebucht")
    void startguthaben() {
    assertEquals(Betrag.euro(100), konto(Betrag.euro(100)).getKontostand());
    }
    @Test
    @DisplayName("Einzahlen erhöht den Kontostand")
    void einzahlen() {
    Konto konto = konto();
    konto.einzahlen(Betrag.euro(19, 99));
    konto.einzahlen(Betrag.euro(0, 1));
    assertEquals(Betrag.euro(20), konto.getKontostand());
    }
    @Test
    @DisplayName("Abheben mit Deckung")
    void abhebenMitDeckung() {
    Konto konto = konto(Betrag.euro(100));
    assertTrue(konto.abheben(Betrag.euro(100)));
    assertEquals(Betrag.NULL, konto.getKontostand());
    }
    @Test
    @DisplayName("Abheben ohne Deckung ändert nichts")
    void abhebenOhneDeckung() {
    Konto konto = konto(Betrag.euro(100));
    assertFalse(konto.abheben(Betrag.euro(100, 1)));
    assertEquals(Betrag.euro(100), konto.getKontostand());
    }
    @Test
    @DisplayName("Überweisen bucht auf beiden Konten")
    void ueberweisen() throws KontoNichtGedecktException {
    Konto von = konto(Betrag.euro(100));
    Konto nach = konto();
    von.ueberweisen(nach, Betrag.euro(30));
    assertEquals(Betrag.euro(70), von.getKontostand());
    assertEquals(Betrag.euro(30), nach.getKontostand());
    }
    @Test
    @DisplayName("Überweisen ohne Deckung ändert keines der Konten")
    void ueberweisenOhneDeckung() {
    Konto von = konto(Betrag.euro(10));
    Konto nach = konto();
    KontoNichtGedecktException fehler = assertThrows(KontoNichtGedecktException.class,
    () -> von.ueberweisen(nach, Betrag.euro(30)));
    assertEquals(Betrag.euro(20), fehler.getFehlbetrag());
    assertEquals(Betrag.euro(10), von.getKontostand());
    assertEquals(Betrag.NULL, nach.getKontostand());
    }
    @Test
    @DisplayName("Jedes Konto bekommt eine eigene Nummer")
    void eigeneNummern() {
    assertNotEquals(konto().getKontonummer(), konto().getKontonummer());
    }
    @Test
    @DisplayName("Ein Konto ist gleich zu sich selbst, aber nicht zu einem anderen")
    void gleichheit() {
    Konto konto = konto();
    Konto dasselbe = konto;
    assertEquals(konto, dasselbe);
    assertNotEquals(konto, konto());
    assertEquals(konto.hashCode(), dasselbe.hashCode());
    }
    @Test
    @DisplayName("toString enthält Kontokennung, Inhaber und Kontostand")
    void textdarstellung() {
    Konto konto = konto(Betrag.euro(19, 99));
    String text = konto.toString();
    assertTrue(text.contains(konto.getKontokennung()));
    assertTrue(text.contains("Anna Muster"));
    assertTrue(text.contains("19,99 €"));
    }
    @Test
    @DisplayName("Ein neues Konto ist aktiv")
    void neuesKontoIstAktiv() {
    assertEquals(Kontostatus.AKTIV, konto().getStatus());
    }
    @Test
    @DisplayName("Ein gesperrtes Konto nimmt Einzahlungen an, zahlt aber nicht aus")
    void gesperrt() {
    Konto konto = konto(Betrag.euro(100));
    konto.sperren();
    konto.einzahlen(Betrag.euro(5));
    assertEquals(Betrag.euro(105), konto.getKontostand());
    assertThrows(IllegalStateException.class, () -> konto.abheben(Betrag.euro(5)));
    }
    @Test
    @DisplayName("Entsperren macht ein Konto wieder aktiv")
    void entsperren() {
    Konto konto = konto();
    konto.sperren();
    konto.entsperren();
    assertEquals(Kontostatus.AKTIV, konto.getStatus());
    }
    @Test
    @DisplayName("Kündigen geht nur bei leerem Konto")
    void kuendigen() {
    Konto konto = konto(Betrag.euro(10));
    assertThrows(IllegalStateException.class, () -> konto.kuendigen());
    konto.abheben(Betrag.euro(10));
    konto.kuendigen();
    assertEquals(Kontostatus.GEKUENDIGT, konto.getStatus());
    }
    @Test
    @DisplayName("Keine Überweisung auf ein gekündigtes Konto – und kein Geld geht verloren")
    void ueberweisenAufGekuendigtesKonto() {
    Konto von = konto(Betrag.euro(100));
    Konto nach = konto();
    nach.kuendigen();
    assertThrows(IllegalStateException.class, () -> von.ueberweisen(nach, Betrag.euro(30)));
    assertEquals(Betrag.euro(100), von.getKontostand());
    }
    }
  2. Schreibe den Bankautomat mit liesGanzzahl und try-with-resources. Probiere alle Fälle aus: gültige Zahl, Buchstaben, zu viel Geld, negativer Betrag.

    Lösung
    Bankautomat.java
    package de.drv.bank;
    import java.time.LocalDate;
    import java.util.InputMismatchException;
    import java.util.Scanner;
    public class Bankautomat {
    public static void main(String[] args) {
    Kunde anna = new Kunde("Anna Muster", LocalDate.of(2004, 3, 12));
    GiroKonto giro = new GiroKonto(anna, Betrag.euro(200));
    giro.einzahlen(Betrag.euro(100));
    SparKonto spar = new SparKonto(anna, 0.5);
    System.out.println(giro);
    try (Scanner scanner = new Scanner(System.in)) {
    int euro = liesGanzzahl(scanner, "Wie viel Euro auf das Sparkonto überweisen? ");
    try {
    giro.ueberweisen(spar, Betrag.euro(euro));
    System.out.println("Überwiesen. " + giro);
    } catch (KontoNichtGedecktException e) {
    System.out.println("Nicht möglich: " + e.getMessage());
    System.out.println("Es fehlen " + e.getFehlbetrag() + ".");
    } catch (IllegalArgumentException e) {
    System.out.println("Ungültiger Betrag: " + e.getMessage());
    }
    }
    }
    public static int liesGanzzahl(Scanner scanner, String frage) {
    while (true) {
    System.out.print(frage);
    try {
    int zahl = scanner.nextInt();
    scanner.nextLine();
    return zahl;
    } catch (InputMismatchException e) {
    System.out.println("Bitte eine ganze Zahl eingeben.");
    scanner.nextLine();
    }
    }
    }
    }
  3. Lass im catch-Block von liesGanzzahl das scanner.nextLine() weg und gib Buchstaben ein. Was passiert? Wie stoppst du das Programm?

    Lösung

    Eine Endlosschleife: Die Buchstaben bleiben im Scanner liegen, nextInt() scheitert immer wieder, und die Meldung „Bitte eine ganze Zahl eingeben.“ rast über den Bildschirm. Stoppen: in Eclipse mit dem roten Quadrat in der Console, im Terminal mit Strg+C.

  4. Gehe zurück zu einem der Programme aus der Woche – etwa Summe mit Programm-Argumenten aus dem Kapitel Ein- und Ausgabe. Fange die NumberFormatException und die ArrayIndexOutOfBoundsException ab und gib verständliche Meldungen aus.

    Lösung
    public static void main(String[] args) {
    try {
    int a = Integer.parseInt(args[0]);
    int b = Integer.parseInt(args[1]);
    System.out.println(a + " + " + b + " = " + (a + b));
    } catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Bitte zwei Zahlen als Argumente angeben.");
    } catch (NumberFormatException e) {
    System.out.println("Das ist keine ganze Zahl: " + e.getMessage());
    }
    }

    Sauberer wäre bei den fehlenden Argumenten übrigens eine einfache Prüfung if (args.length < 2) vor dem Zugriff – ein fehlendes Argument ist vorhersehbar und braucht keine Exception.