Java versuchen ... fangen

In diesem Tutorial lernen wir die try-catch-Anweisung in Java anhand von Beispielen kennen.

Der try...catch Block in Java wird verwendet, um Ausnahmen zu behandeln und verhindert die abnormale Beendigung des Programms.

Hier ist die Syntax einer try...catch Block in Java.

try{
  // code
}
catch(exception) {
  // code
}

Die try Block enthält den Code, der eine Ausnahme generieren könnte.

Die catch Block enthält den Code, der ausgeführt wird, wenn innerhalb von try eine Ausnahme auftritt blockieren.

Beispiel:Java try...catch-Block

class Main {
  public static void main(String[] args) {

    try {
      int divideByZero = 5 / 0;
      System.out.println("Rest of code in try block");
    }

    catch (ArithmeticException e) {
      System.out.println("ArithmeticException => " + e.getMessage());
    }
  }
}

Ausgabe

ArithmeticException => / by zero

Beachten Sie im obigen Beispiel die Zeile,

int divideByZero = 5 / 0;

Hier versuchen wir, eine Zahl durch Null zu teilen . In diesem Fall tritt eine Ausnahme auf. Daher haben wir diesen Code in try eingeschlossen blockieren.

Wenn das Programm auf diesen Code stößt, wird ArithmeticException tritt ein. Und die Ausnahme wird von catch abgefangen Block und führt den Code innerhalb von catch aus blockieren.

Die catch -Block wird nur ausgeführt, wenn es innerhalb von try eine Ausnahme gibt blockieren.

Hinweis :In Java können wir einen try verwenden Block ohne catch Block. Wir können jedoch keinen catch verwenden Block ohne try blockieren.

Java try...endlich blockieren

Wir können auch den try verwenden Block zusammen mit einem finally-Block.

In diesem Fall wird der finally-Block immer ausgeführt, unabhängig davon, ob es innerhalb des try-Blocks eine Ausnahme gibt oder nicht.

Beispiel:Java try...finally block

class Main {
  public static void main(String[] args) {
    try {
      int divideByZero = 5 / 0;
    }

    finally {
      System.out.println("Finally block is always executed");
    }
  }
}

Ausgabe

Finally block is always executed
Exception in thread "main" java.lang.ArithmeticException: / by zero
        at Main.main(Main.java:4)

Im obigen Beispiel haben wir den try verwendet Block zusammen mit dem finally Block. Wir können sehen, dass der Code innerhalb des try Block verursacht eine Ausnahme.

Der Code innerhalb der finally Block wird unabhängig von der Ausnahme ausgeführt.

Java try...catch...finally blockieren

In Java können wir auch den finally-Block nach try...catch verwenden Block. Zum Beispiel

import java.io.*;

class ListOfNumbers {

  // create an integer array
  private int[] list = {5, 6, 8, 9, 2};

  // method to write data from array to a fila
  public void writeList() {
    PrintWriter out = null;

    try {
      System.out.println("Entering try statement");

      // creating a new file OutputFile.txt
      out = new PrintWriter(new FileWriter("OutputFile.txt"));

      // writing values from list array to Output.txt
      for (int i = 0; i < 7; i++) {
        out.println("Value at: " + i + " = " + list[i]);
      }
    }
    
    catch (Exception e) {
      System.out.println("Exception => " + e.getMessage());
    }
    
    finally {
      // checking if PrintWriter has been opened
      if (out != null) {
        System.out.println("Closing PrintWriter");
        // close PrintWriter
        out.close();
      }
      
      else {
        System.out.println("PrintWriter not open");
      }
    }

  }
}

class Main {
  public static void main(String[] args) {
    ListOfNumbers list = new ListOfNumbers();
    list.writeList();
  }
}

Ausgabe

Entering try statement
Exception => Index 5 out of bounds for length 5
Closing PrintWriter

Im obigen Beispiel haben wir ein Array namens list erstellt und eine Datei namens output.txt . Hier versuchen wir, Daten aus dem Array zu lesen und in der Datei zu speichern.

Beachten Sie den Code,

for (int i = 0; i < 7; i++) {
  out.println("Value at: " + i + " = " + list[i]);
}

Hier ist die Größe des Arrays 5 und das letzte Element des Arrays ist bei list[4] . Wir versuchen jedoch, auf Elemente unter a[5] zuzugreifen und a[6] .

Daher generiert der Code eine Ausnahme, die vom catch-Block abgefangen wird.

Seit dem finally -Block immer ausgeführt wird, haben wir Code eingefügt, um PrintWriter zu schließen innerhalb des finally-Blocks.

Es ist eine gute Praxis, den finally-Block zu verwenden, um wichtigen Bereinigungscode wie das Schließen einer Datei oder Verbindung einzufügen.

Hinweis :Es gibt einige Fälle, in denen ein finally Block wird nicht ausgeführt:

Verwendung von System.exit() Methode
Eine Ausnahme tritt in finally auf blockieren
Der Tod eines Threads

Mehrere Catch-Blöcke

Für jeden try Block kann es null oder mehr catch geben Blöcke. Mehrere catch -Blöcke ermöglichen es uns, jede Ausnahme anders zu behandeln.

Der Argumenttyp jedes catch block gibt die Art der Ausnahme an, die von ihm behandelt werden kann. Zum Beispiel

class ListOfNumbers {
  public int[] arr = new int[10];

  public void writeList() {

    try {
      arr[10] = 11;
    }
    
    catch (NumberFormatException e1) {
      System.out.println("NumberFormatException => " + e1.getMessage());
    }
    
    catch (IndexOutOfBoundsException e2) {
      System.out.println("IndexOutOfBoundsException => " + e2.getMessage());
    }

  }
}

class Main {
  public static void main(String[] args) {
    ListOfNumbers list = new ListOfNumbers();
    list.writeList();
  }
}

Ausgabe

IndexOutOfBoundsException => Index 10 out of bounds for length 10

In diesem Beispiel haben wir ein Integer-Array mit dem Namen arr erstellt der Größe 10 .

Da der Array-Index bei 0 beginnt , das letzte Element des Arrays ist bei arr[9] . Beachten Sie die Anweisung,

arr[10] = 11;

Hier versuchen wir, dem Index 10 einen Wert zuzuweisen . Daher IndexOutOfBoundException auftritt.

Wenn eine Ausnahme im try auftritt blockieren,

Die Ausnahme wird zum ersten catch geworfen Block. Das erste catch Block verarbeitet kein IndexOutOfBoundsException , also wird es an den nächsten catch weitergegeben blockieren.
Der zweite catch block im obigen Beispiel ist der geeignete Ausnahmehandler, da er einen IndexOutOfBoundsException verarbeitet . Daher wird es ausgeführt.

Mehrere Ausnahmen abfangen

Ab Java SE 7 und höher können wir jetzt mehr als einen Ausnahmetyp mit einem catch abfangen blockieren.

Dadurch wird die Code-Duplizierung reduziert und die Code-Einfachheit und -Effizienz erhöht.

Jeder Ausnahmetyp, der von catch behandelt werden kann Block wird durch einen senkrechten Strich | getrennt .

Seine Syntax ist:

try {
  // code
} catch (ExceptionType1 | Exceptiontype2 ex) { 
  // catch block
}

Weitere Informationen finden Sie unter Java fängt mehrere Ausnahmen ab.

Java try-with-resources-Anweisung

Die Versuch-mit-Ressourcen -Anweisung ist eine try-Anweisung, die eine oder mehrere Ressourcendeklarationen hat.

Seine Syntax ist:

try (resource declaration) {
  // use of the resource
} catch (ExceptionType e1) {
  // catch block
}

Die Ressource ist ein Objekt, das am Ende des Programms geschlossen werden soll. Es muss in der try-Anweisung deklariert und initialisiert werden.

Nehmen wir ein Beispiel.

try (PrintWriter out = new PrintWriter(new FileWriter("OutputFile.txt")) {
  // use of the resource
}

Die Versuch-mit-Ressourcen -Anweisung wird auch als automatisches Ressourcenmanagement bezeichnet . Diese Anweisung schließt automatisch alle Ressourcen am Ende der Anweisung.

Um mehr zu erfahren, besuchen Sie die java try-with-resources-Anweisung.

Java-Ausnahmebehandlung Java-Wurf und Würfe

Java