Java löst eine Ausnahme aus

Überall, wo wir hingehen, erwarten uns unvorhersehbare Ereignisse. Erdbeben, irrationale Handlungen von Menschen, Meteoriten ... oder etwas einfacheres – eine Glühbirne brennt durch, eine Bankkarte entmagnetisiert sich, eine Benzinanzeige geht kaputt. Wir können unvorhersehbare Ereignisse nicht verhindern, aber wir können zumindest teilweise darauf vorbereitet sein. Das heißt, wir müssen bestimmte Mechanismen vorbereiten, um mit ihnen umzugehen. In der Welt der Programmierung, insbesondere in der Java-Sprache, werden Ereignisse, die die normale Funktion eines Programms verhindern, als Ausnahmen bezeichnet, und die Mechanismen zur Verhinderung von Programmabstürzen werden als Ausnahmebehandlung bezeichnet. Wenn also in einem Programm ein unerwartetes Ereignis auftritt, beispielsweise eine Division durch Null, sollte es eine Ausnahme „auslösen“. Die Ausnahmebehandlung ist ein wichtiger Aspekt der Java-Programmierung, der Entwicklern hilft, Fehler und Ausnahmen zu verwalten, die während der Ausführung eines Programms auftreten können. In diesem Artikel konzentrieren wir uns auf eines der grundlegenden Konzepte der Ausnahmebehandlung: das Java- Schlüsselwort throw und wie man es zum Auslösen einer Ausnahme verwendet.

Was ist eine Ausnahme in Java?

Eine Ausnahme ist ein Ereignis, das während der Ausführung eines Programms auftritt und den normalen Ablauf der Programmanweisungen stört. Wenn eine Ausnahme auftritt, wird die Programmausführung angehalten und die Fehlermeldung wird auf der Konsole angezeigt. In Java gibt es zwei Arten von Ausnahmen: aktivierte und nicht aktivierte. Geprüfte Ausnahmen werden zur Kompilierzeit geprüft und der Compiler stellt sicher, dass sie von der aufrufenden Methode abgefangen oder deklariert werden. Andererseits werden ungeprüfte Ausnahmen zur Kompilierungszeit nicht geprüft und können abgefangen werden oder unabgefangen bleiben. Hier ist ein Beispiel für Code, in dem ein Fehler auftreten kann, der Compiler ihn jedoch überspringt.

public class Factorial {
   public static long getFactorial(final int number) {
           long fact = 1;
           for (int i = 1; i <= number; i++) {
               fact = fact * i;
           }
           return fact;
   }

   public static void main(String[] args) {
       System.out.println(getFactorial(-5));
       System.out.println(getFactorial(21));

   }

}

Hier ist die Ausgabe des Programms: Das Programm wurde ordnungsgemäß beendet, lieferte jedoch ein falsches Ergebnis. Im ersten Fall, weil das Funktionsargument negativ war und die Fakultät für negative Zahlen nicht funktioniert. Im zweiten Fall war das Ergebnis falsch, da die Zahl zu groß ist, um ihre Fakultät im Bereich des langen Typs zu zählen. Hier ist ein weiteres Beispiel. Schreiben wir ein Programm, in dem wir eine Zahl durch eine andere dividieren.

public class DivisionExample {

       public static void main(String[] args) {
           int a = 10;
           int b = 0;
           int result = divide(a, b);
           System.out.println(result);
       }

       public static int divide(int a, int b) {
           return a / b;
       }
}

In diesem Beispiel wird eine ArithmeticException ausgelöst, da die Variable b Null ist. Dieser Fehler wird jedoch nicht behandelt, sodass das Programm mit einem falschen Status beendet wird.

So lösen Sie eine Ausnahme in Java aus

In Java sind Ausnahmen ebenfalls Objekte, sodass eine Ausnahme genauso ausgelöst wird wie ein neu erstelltes Ausnahmeobjekt. Mit der throw-Anweisung wird in einem Programm eine Ausnahme ausgelöst. Normalerweise werden diese beiden Vorgänge (Objekterstellung und Auslösen einer Ausnahme) zu einem zusammengefasst:

throw new Exception("error…");

Das Schlüsselwort throw wird in Java verwendet, um eine Ausnahme von einer Methode oder einem Codeblock auszulösen, wenn ein Fehler oder eine Ausnahmebedingung auftritt, die das Programm zur Laufzeit nicht verarbeiten kann. Der Programmfluss wird zum nächstgelegenen Catch-Block umgeleitet. Dieser Block kann die Ausnahme verwalten.

Beispiel für die Verwendung des Schlüsselworts „throw“.

Um die Funktionalität des Schlüsselworts throw in Java zu veranschaulichen, nehmen wir ein Beispiel. Schreiben wir eine Methode zur Berechnung der Fakultät einer Zahl. Wenn die Zahl negativ ist, kann sie nicht berechnet werden, daher muss eine Ausnahme ausgelöst werden. Wenn die Zahl ebenfalls zu groß ist, überschreitet das Fakultätsergebnis die maximale Größe eines langen Typs und es wird eine weitere Ausnahme ausgelöst. Hier haben wir eine Implementierung der Methode:

public Class Factorial {

public static long getFactorial(final int number) {
   if ((number >= 0) && (number < 21)) {
       long fact = 1;
       for (int i = 1; i <= number; i++) {
           fact = fact * i;
       }
       return fact;
   } else {

//throw new exception here
       throw new IllegalArgumentException("THe argument isn't legal");
   }
}

 public static void main(String[] args) {
       System.out.println(getFactorial(-5));
       System.out.println(getFactorial(21));

   }
}

Wenn in diesem Beispiel der Wert von number negativ ist, wird das Schlüsselwort throw verwendet, um eine Instanz der IllegalArgumentException -Klasse auszulösen. Wenn Sie das Programm ausführen, wird auf der Konsole die Meldung „Das Argument ist nicht zulässig“ angezeigt. Die Programmausführung wird angehalten.

Keine Fehler mehr: Beispiel für das Abfangen einer Ausnahme

Erinnern wir uns nun an das zweite Beispiel mit Division durch Null und führen es mit Ausnahmebehandlung aus.

public class DivisionExample {

    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        try {
            int result = divide(a, b);
            System.out.println(result);
        } catch (ArithmeticException e) {
            System.out.println("Error: division by zero");
        }
    }

    public static int divide(int a, int b) {
        return a / b;
    }
}

In diesem Beispiel haben wir ein Try-Catch- Konstrukt hinzugefügt, um die Division-durch-Null-Ausnahme zu behandeln. Kurz gesagt ist try-catch-finally ein Konstrukt der Java-Programmiersprache, mit dem Sie Ausnahmen behandeln und Code ausführen können, unabhängig davon, ob eine Ausnahme aufgetreten ist oder nicht. try-catch-finally besteht aus drei Blöcken:

• Der Try- Block. Hier wird potenziell gefährlicher Code ausgeführt. Das ist Code, der eine Ausnahme auslösen kann. Wenn innerhalb eines Try- Blocks eine Ausnahme auftritt , wird die Ausführung des Codes in diesem Block abgebrochen und die Steuerung wird an den Catch-Block übertragen.
• Der Catch- Block. Hier wird die ausgelöste Ausnahme behandelt. Im Catch- Block können Sie angeben, welche Ausnahme abgefangen werden soll und welche Logik beim Abfangen ausgeführt werden soll.
Der finale Block. Dieser wird unabhängig davon ausgeführt, ob eine Ausnahme aufgetreten ist oder nicht. Der „finally“ -Block wird beispielsweise verwendet, um Ressourcen freizugeben (z. B. das Schließen einer Datei oder eines Sockets), die in einem „try“-Block zugewiesen wurden. Sie können diesen Block weglassen.

Das try-catch-finally- Konstrukt ermöglicht eine genauere Steuerung der Programmausführung in Ausnahmesituationen und hilft, bei Fehlern einen unerwarteten Programmabbruch zu verhindern. Kehren wir nun zu unserem Beispiel zurück. Wenn während der Division-Methode eine Division durch Null erfolgt, wird eine ArithmeticException ausgelöst, die vom Catch-Block abgefangen wird. Im Catch- Block geben wir einfach eine Fehlermeldung an die Konsole aus. Wenn keine Ausnahme auftritt, setzt das Programm seine Ausführung fort.

wirft Schlüsselwort

Das Schlüsselwort throws wird in der Methodensignatur verwendet. Wenn ja, bedeutet dies, dass in der Methode eine Ausnahme ausgelöst wird. Dies kann Ausnahmen im Aufrufstapel nach oben verbreiten und anzeigen, dass Ausnahmen nicht in der aktuellen Methode behandelt werden müssen. In Java können „Throws“ auch verwendet werden, um auf benutzerdefinierte Ausnahmen zu verweisen, die in einem Programm definiert sind. Beispielsweise kann eine Methode eine Division zweier Zahlen durchführen, aber eine IllegalArgumentException auslösen , wenn das zweite Argument Null ist:

public static double divide(double a, double b) throws IllegalArgumentException {
    if (b == 0) {
        throw new IllegalArgumentException("Division by zero is not allowed");
    }
    return a / b;
}

Diese Methode verwendet das Schlüsselwort throws, um anzugeben, dass eine IllegalArgumentException ausgelöst werden kann, wenn das zweite Argument null ist. Tritt während der Ausführung der Methode eine solche Ausnahme auf, wird sie zur Verarbeitung an die aufrufende Methode übergeben. Beispiel für einen Methodenaufruf:

public static void main(String[] args) {
    double result = 0;
    try {
        result = divide(10, 0);
    } catch (IllegalArgumentException e) {
        System.out.println("Error: " + e.getMessage());
    }
    System.out.println("Result: " + result);
}

In diesem Beispiel wird die Methode „divide()“ mit den Argumenten 10 und 0 aufgerufen, was eine IllegalArgumentException auslöst, da eine Division durch Null nicht möglich ist. Die Ausnahme wird von einem Try-Catch- Block abgefangen und eine Fehlermeldung angezeigt. Das Programm ergibt einen Wert von Null, da die Ausnahme die Ausführung der Methode „divide()“ beendet .