Tracks
/
Java
Java
/
Übungen
/
Das Taschenrechner-Rätsel
Das Taschenrechner-Rätsel

Das Taschenrechner-Rätsel

Lernübung

Einführung

Ausnahmen

Die Programmiersprache Java verwendet Ausnahmen, um Fehler und andere außergewöhnliche Ereignisse zu behandeln.

Was ist eine Ausnahme

Eine Ausnahme ist ein Ereignis, das während der Ausführung eines Programms auftritt und den normalen Ablauf der Anweisungen unterbricht. Ausnahmen werden in Java explizit ausgelöst, und das Auslösen einer Ausnahme nennt man eine Ausnahme werfen. Das Behandeln einer Ausnahme nennt man eine Ausnahme abfangen.

In Java sind alle Ausnahmen Unterklassen der Klasse Exception, die selbst eine Unterklasse von Throwable ist.

Java unterscheidet zwei Arten von Ausnahmen:

  1. Geprüfte Ausnahmen
  2. Ungeprüfte Ausnahmen
Geprüfte Ausnahmen

Geprüfte Ausnahmen sind außergewöhnliche Bedingungen, die eine Anwendung vorhersehen und von denen sie sich erholen sollte. Ein Beispiel für eine geprüfte Ausnahme ist die FileNotFoundException, die auftritt, wenn eine Methode versucht, eine Datei zu lesen, die nicht existiert.

Dieser Ausnahmetyp wird zur Kompilierzeit geprüft: Methoden, die geprüfte Ausnahmen werfen, sollten dies in ihrer Methodensignatur angeben, und Code, der eine Methode aufruft, die eine geprüfte Ausnahme werfen könnte, muss diese behandeln, sonst lässt sich der Code nicht kompilieren.

Alle geprüften Ausnahmen sind Unterklassen von Exception, die nicht von RuntimeException erben.

Ungeprüfte Ausnahmen

Ungeprüfte Ausnahmen sind außergewöhnliche Bedingungen, die eine Anwendung normalerweise nicht vorhersehen oder von denen sie sich nicht erholen kann. Ein Beispiel für eine ungeprüfte Ausnahme ist die NullPointerException, die auftritt, wenn eine Methode einen Wert erwartet, der nicht null ist, aber null erhält.

Dieser Ausnahmetyp wird nicht zur Kompilierzeit geprüft: Methoden, die ungeprüfte Ausnahmen werfen, müssen dies nicht in ihrer Methodensignatur angeben, und Code, der eine Methode aufruft, die eine ungeprüfte Ausnahme werfen könnte, muss diese nicht behandeln.

Alle ungeprüften Ausnahmen erben von RuntimeException, die selbst eine Erweiterung von Exception ist.

Ausnahmen werfen

Eine Methode in Java kann mit der throw-Anweisung eine Ausnahme werfen.

Eine geprüfte Ausnahme werfen

Wenn du aus einer Methode eine geprüfte Ausnahme wirfst, musst du dies in der Methodensignatur mit dem Schlüsselwort throws angeben, wie das folgende Beispiel zeigt. Dadurch muss der aufrufende Code damit rechnen, dass eine Ausnahme geworfen werden könnte, und sie entsprechend behandeln.

public class InsufficientBalanceException extends Exception {

}

public class BankAccount {
  public void withdraw(double amount) throws InsufficientBalanceException {
    if (balance < amount) {
      throw new InsufficientBalanceException();
    }

    // rest of the method implementation
  }
}
Eine ungeprüfte Ausnahme werfen

Wenn du aus einer Methode eine ungeprüfte Ausnahme wirfst, musst du dies nicht in der Methodensignatur angeben, obwohl es unterstützt wird.

public class BankAccount {
  public void withdraw(double amount) {
    if (amount < 0) {
      throw new IllegalArgumentException("Cannot withdraw a negative amount");
    }

    // rest of the method implementation
  }
}

Ausnahmen behandeln

Ausnahmen behandelst du in Java mit den Schlüsselwörtern try, catch und finally.

  • Code-Anweisungen, die eine Ausnahme werfen könnten, sollten in einen try-Block eingeschlossen werden.
  • Auf den try-Block folgen ein oder mehrere catch-Blöcke, die die im try-Block geworfenen Ausnahmen abfangen.
  • Auf die catch-Blöcke folgt optional ein finally-Block, der immer nach dem try-Block ausgeführt wird, unabhängig davon, ob eine Ausnahme geworfen wurde oder nicht.

Das folgende Beispiel zeigt, wie diese Schlüsselwörter zusammenwirken:

public class ATM {
  public void withdraw(BankAccount bankAccount, double amount) {
    try {
      System.out.println("Withdrawing " + amount);
      bankAccount.withdraw(amount);
      System.out.println("Withdrawal succeeded");
    } catch (InsufficientBalanceException) {
      System.out.println("Withdrawal failed: insufficient balance");
    } catch (RuntimeException e) {
      System.out.println("Withdrawal failed: " + e.getMessage());
    } finally {
      System.out.println("Current balance: " + bankAccount.getBalance());
    }
  }
}

In diesem Beispiel wird, wenn keine Ausnahme geworfen wird, Folgendes ausgegeben:

Withdrawing 10.0
Withdrawal succeeded
Current balance: 5.0

Wenn jedoch die Anweisung bankAccount.withdraw(amount) eine InsufficientBalanceException wirft, wird Folgendes ausgegeben:

Withdrawing 10.0
Withdrawal failed: insufficient balance
Current balance: 5.0

Oder, falls bankAccount.withdraw(amount) eine ungeprüfte Ausnahme wirft, wird Folgendes ausgegeben:

Withdrawing -10.0
Withdrawal failed: Cannot withdraw a negative amount
Current balance: 5.0

Fehler

Java kennt außerdem eine separate Kategorie namens Fehler, das sind schwerwiegende Probleme, die außerhalb einer Anwendung liegen. Ein Beispiel für einen Fehler ist der OutOfMemoryError, der auftritt, wenn eine Anwendung mehr Speicher zu nutzen versucht, als im System verfügbar ist.

Wie ungeprüfte Ausnahmen werden Fehler nicht zur Kompilierzeit geprüft. Der Unterschied ist, dass sie Probleme auf Systemebene darstellen und im Allgemeinen von der Java Virtual Machine oder der Umgebung geworfen werden, nicht von der Anwendung. Anwendungen sollten im Allgemeinen nicht versuchen, sie abzufangen oder zu behandeln.

Alle Fehler in Java erben von der Klasse Error.

Anleitung

In dieser Übung baust du die Fehlerbehandlung für einen einfachen Rechner für Ganzzahlen. Um es einfach zu halten, sind Methoden für die Addition, Multiplikation und Division bereits vorgegeben.

Das Ziel ist ein funktionierender Rechner, der einen String nach folgendem Muster zurückgibt: 16 + 51 = 67, wenn er die Argumente 16, 51 und + erhält.

CalculatorConundrum calculator = new CalculatorConundrum();

calculator.calculate(16, 51, "+");
// => returns "16 + 51 = 67"

calculator.calculate(32, 6, "*");
// => returns "32 * 6 = 192"

calculator.calculate(512, 4, "/");
// => returns "512 / 4 = 128"

1. Implementiere die Methode calculate, um einige grundlegende Operationen zu unterstützen

Die zentrale Methode, die du in dieser Aufgabe implementierst, ist die Methode CalculatorConundrum.calculate(). Sie nimmt drei Argumente entgegen. Die ersten beiden Argumente operand1 und operand2 sind Ganzzahlen, auf die eine Operation angewendet wird. Das dritte Argument operation ist vom Typ String, und für diese Übung musst du die folgenden Operationen implementieren:

  • Addition mit dem String +
  • Multiplikation mit dem String *
  • Division mit dem String /

2. Behandle unzulässige Operationen

Passe die Methode CalculatorConundrum.calculate() an, um unzulässige Operationen zu behandeln:

  • Wenn das Argument operation null ist, soll eine IllegalArgumentException mit der Meldung Operation cannot be null geworfen werden.
  • Wenn das Argument operation "" ist, soll eine IllegalArgumentException mit der Meldung Operation cannot be empty geworfen werden.
  • Wenn das Argument operation eine andere Operation als +, * oder / ist, soll eine IllegalOperationException mit der Meldung Operation '{operation}' does not exist geworfen werden.
calculator.calculate(10, 1, null);
// => throws IllegalArgumentException with message "Operation cannot be null"

calculator.calculate(10, 1, "");
// => throws IllegalArgumentException with message "Operation cannot be empty"

calculator.calculate(10, 1, "-");
// => throws IllegalOperationException with message "Operation '-' does not exist"

3. Behandle die Ausnahme, die beim Teilen durch null geworfen wird

In Java wird beim Versuch, durch null zu teilen, eine ArithmeticException geworfen. Passe die Methode CalculatorConundrum.calculate() an, um diese Ausnahme abzufangen und dann eine IllegalOperationException mit der Meldung Division by zero is not allowed und der abgefangenen ArithmeticException als Ursache zu werfen.

calculator.calculate(512, 0, "/");
// => throws IllegalOperationException with message "Division by zero is not allowed"
Über GitHub bearbeiten Der Link öffnet sich in einem neuen Fenster oder Tab
Java Exercism

Bereit, mit Das Taschenrechner-Rätsel zu starten?

Melde dich bei Exercism an, um Java mit 26 Konzepte158 Übungen und echtem menschlichen Mentoring zu lernen und zu meistern, alles kostenlos.