Java Try - Catch

Bei der Programmausführung können Fehler auftreten. Es ist ein häufiges Problem für jeden Programmierer, vom Anfänger bis zum echten Profi. Nicht alle Fehler sind auf das Verschulden des Entwicklers zurückzuführen. Einige davon sind schwer vorherzusagen, manchmal ist es sogar unmöglich. Während des Herunterladens eines Programms kann es beispielsweise vorkommen, dass die Netzwerkverbindung plötzlich unterbrochen wird oder der Strom ausfällt. Solche Situationen werden Ausnahmen genannt. Try und Catch sind die Konstruktionsteile, die zur Behandlung von Ausnahmen verwendet werden.

Java Try-and-Catch-Block

Wenn ein Fehler auftritt, stoppt Java normalerweise und generiert eine Fehlermeldung. Dieser Vorgang wird als „Java löst eine Ausnahme“ bezeichnet. Java bietet spezielle Möglichkeiten zur Behandlung von Ausnahmen. Eine davon ist Try...Catch...finally Construction. Hier ist die Syntax von Try-Block, Catch-Block und Final-Block.

//try block
try {
  // Block of code to try
}
//try catch
catch(Exception e) {
  // Block of code to handle errors
}
finally {
 // Optional block of code
          }

Wenn im Try-Block eine Ausnahme auftritt, geht die Steuerung an den Catch-Block über, der die Ausnahme behandeln kann. Wenn kein solcher Block gefunden wird, wird dem Benutzer eine nicht behandelte Ausnahmemeldung angezeigt und die weitere Ausführung des Programms wird gestoppt. Um einen solchen Notstopp zu verhindern, müssen Sie den try..catch-Block verwenden.

Kurz über die Schlüsselwörter Try, Catch und Throws

Die Ausnahmebehandlung in Java basiert auf der Verwendung der folgenden Schlüsselwörter in einem Programm:

• try – definiert einen Codeblock, in dem eine Ausnahme auftreten kann;
• Catch – definiert den Codeblock, in dem die Ausnahme behandelt wird;
• final – definiert einen Codeblock, der optional ist, aber falls vorhanden, trotzdem ausgeführt wird, unabhängig von den Ergebnissen des try-Blocks.

Diese Schlüsselwörter werden verwendet, um spezielle Verarbeitungskonstrukte im Programmcode zu erstellen: Try Catch und Try Catch Finally}.

• throw – wird verwendet, um eine Ausnahme auszulösen;
• throws – werden in Methodensignaturen verwendet, um zu warnen, dass eine Methode möglicherweise eine Ausnahme auslöst.

Einfaches Beispiel für eine Try-Catch-Konstruktion

Nehmen wir an, wir haben ein Programm mit einem Array.

public class TryTest {
   public static void main(String[] args) {
       int[] myArray = new int[5];
       myArray[7] = 8;
       System.out.println(myArray[7]);
   }
}

Da wir versuchen, auf ein Array-Element mit einem nicht vorhandenen Index zuzugreifen, wird das Programm mit einer Fehlermeldung beendet: Lassen Sie uns dieses Programm ändern und diese Ausnahme mit einem Try-Catch behandeln. Zuerst kommt der Try-Block, später der Catch-Block.

//try catch example
public class TryTest {
   public static void main(String[] args) {
       try {
           int[] myArray = new int[5];
           myArray[7] = 8;
           System.out.println(myArray[7]);
       } catch (Exception myEx) {
           System.out.println("The exception was handled...");
       }

       System.out.println("This is the end of the program...");
   }
}

Jetzt hat sich die Ausgabe geändert: In diesem Fall wurde das Programm korrekt abgeschlossen, unsere Meldung wird auf dem Bildschirm angezeigt. Die korrekte Beendigung des Programms wird durch den Code 0 am Ende des Prozesses signalisiert, während der falsche Code durch 1 signalisiert wird. Bei Verwendung eines try...catch-Blocks werden alle Anweisungen zwischen den try- und Catch-Anweisungen zuerst ausgeführt. Wenn im Try-Block eine Ausnahme auftritt, wird die normale Ausführungsreihenfolge angehalten und mit der Catch-Anweisung fortgefahren. Wenn also die Programmausführung die Zahlen[7]=8 erreicht; Zeile stoppt das Programm und geht zum Catch-Block. In unserem Fall haben wir die Variable myEx mit dem Typ Exception deklariert. Dies ist die Basisklasse für alle Ausnahmen und kann daher unterschiedlich sein. Beispielsweise gibt es Ausnahmen, die für Stapelüberläufe verantwortlich sind, die über die Array-Indizierung hinausgehen, wie in unserem Fall, auf Null zeigen und so weiter. Wenn wir die Art der Ausnahme nicht erraten hätten, wäre das Programm ebenfalls falsch beendet worden. Der Einfachheit halber haben wir jedoch den Typ Exception gewählt, der die Basisklasse für alle Ausnahmen darstellt. Die Catch-Anweisung (Exception myEx) behandelt also fast alle Ausnahmen. Behandlung der Ausnahme in diesem Fall. Nach Abschluss des Catch-Blocks setzt das Programm seine Arbeit fort und führt alle anderen Anweisungen nach dem Catch-Block aus. Wenn Sie aufgetretene Ausnahmen sehen möchten, können Sie das Programm veranlassen, einen Stack-Trace der Methodenaufrufe zu drucken. Dies ist, was die JVM tut, wenn eine nicht abgefangene Ausnahme auftritt: Sie stoppt die Ausführung des Programms und druckt einen Stack-Trace nach der Ausführung des Codes des „finally“-Blocks, falls vorhanden.

public class TryTest {
   public static void main(String[] args) {
       try {
           int[] myArray = new int[5];
           myArray[7] = 8;
           System.out.println(myArray[7]);
       } catch (Exception myEx) {

         myEx.printStackTrace();
       }

       System.out.println("This is the end of the program...");
   }
}

Die Behandlung der Ausnahme besteht in diesem Fall darin, den Fehler-Trace-Stack mithilfe der in der Exception- Klasse definierten printStackTrace()- Methode an die Konsole zu drucken . Das Programm wurde jedoch korrekt beendet.

Endlich! Nach dem Fang

Im Beispiel und in den Definitionen der Schlüsselwörter zur Ausnahmebehandlung haben wir den „finally“-Block erwähnt. Es ist optional, aber falls vorhanden, wird es unabhängig von den Ergebnissen des try-Blocks ausgeführt. Ändern wir den Ausnahmetyp in NullPointerException.

public class TryTest {
   public static void main(String[] args) {
       try {
           int[] myArray = new int[5];
           myArray[7] = 8;
           System.out.println(myArray[7]);
       } catch (NullPointerException myEx) {
           System.out.println("The exception was handled...");

       }

       finally{
           System.out.println(" finally");
       }

       System.out.println("This is the end of the program...");
   }
}

Hier ist die Ausgabe: Übrigens können wir angeben, welche Art von Ausnahme korrekt ist. Hier ist es IndexOutOfBoundsException.

public class TryTest {
   public static void main(String[] args) {
       try {
           int[] myArray = new int[5];
           myArray[7] = 8;
           System.out.println(myArray[7]);
       } catch (IndexOutOfBoundsException myEx) {
           System.out.println("The exception was handled...");

       }

       finally{
           System.out.println(" finally");
       }

       System.out.println("This is the end of the program...");
   }
}

In diesem Fall sieht die Ausgabe wie folgt aus:

Wie funktionieren Ausnahmen?

Der Punkt ist, dass alle diese Wörter – Catch, Throw, Throws nur mit java.lang.Throwable oder seinen Nachkommen verwendet werden können. Sie können beispielsweise Folgendes tun:

public class MyClass {
    public static void main(String[] args) {
        try {
        } catch (Throwable thr) {
}
    }
}

Allerdings geht das nicht so:

public class MyClass {
public static void main(String[] args) {
        try {
        } catch (String thr) {
}
    }
}