Java proberen...vangen

In deze tutorial zullen we met behulp van voorbeelden leren over het try catch-statement in Java.

De try...catch blok in Java wordt gebruikt om uitzonderingen af ​​te handelen en voorkomt de abnormale beëindiging van het programma.

Hier is de syntaxis van een try...catch blok in Java.

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

De try blok bevat de code die een uitzondering zou kunnen genereren.

De catch blok bevat de code die wordt uitgevoerd wanneer er een uitzondering optreedt binnen de try blok.

Voorbeeld:Java try...catch-blok

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());
    }
  }
}

Uitvoer

ArithmeticException => / by zero

Let in het bovenstaande voorbeeld op de regel,

int divideByZero = 5 / 0;

Hier proberen we een getal te delen door nul . In dit geval treedt er een uitzondering op. Daarom hebben we deze code ingesloten in de try blok.

Wanneer het programma deze code tegenkomt, ArithmeticException komt voor. En de uitzondering wordt opgevangen door de catch blok en voert de code uit binnen de catch blok.

De catch blok wordt alleen uitgevoerd als er een uitzondering bestaat binnen de try blok.

Opmerking :In Java kunnen we een try . gebruiken blok zonder een catch blok. We kunnen echter geen catch . gebruiken blok zonder een try blok.

Java proberen...eindelijk blokkeren

We kunnen ook de try . gebruiken blok samen met een definitief blok.

In dit geval wordt het final-blok altijd uitgevoerd, of er nu een uitzondering is in het try-blok of niet.

Voorbeeld:Java proberen...eindelijk blokkeren

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

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

Uitvoer

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

In het bovenstaande voorbeeld hebben we de try . gebruikt blok samen met de finally blok. We kunnen zien dat de code in de try blok veroorzaakt een uitzondering.

Echter, de code binnen de finally blok wordt uitgevoerd ongeacht de uitzondering.

Java try...catch...finally block

In Java kunnen we ook het laatste blok gebruiken na de try...catch blok. Bijvoorbeeld,

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();
  }
}

Uitvoer

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

In het bovenstaande voorbeeld hebben we een array gemaakt met de naam list en een bestand met de naam output.txt . Hier proberen we gegevens uit de array te lezen en op te slaan in het bestand.

Let op de code,

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

Hier is de grootte van de array 5 en het laatste element van de array is op list[4] . We proberen echter toegang te krijgen tot elementen op a[5] en a[6] .

Daarom genereert de code een uitzondering die wordt opgevangen door het catch-blok.

Sinds de finally blok wordt altijd uitgevoerd, we hebben code toegevoegd om de PrintWriter . te sluiten binnen het slotblok.

Het is een goede gewoonte om eindelijk block te gebruiken om belangrijke opschooncode op te nemen, zoals het sluiten van een bestand of verbinding.

Opmerking :Er zijn gevallen waarin een finally blok wordt niet uitgevoerd:

• Gebruik van System.exit() methode
• Er treedt een uitzondering op in de finally blok
• De dood van een draad

Meerdere vangstblokken

Voor elke try blok, er kunnen nul of meer zijn catch blokken. Meerdere catch blokken stellen ons in staat om elke uitzondering op een andere manier af te handelen.

Het argumenttype van elke catch blok geeft het type uitzondering aan dat erdoor kan worden afgehandeld. Bijvoorbeeld,

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();
  }
}

Uitvoer

IndexOutOfBoundsException => Index 10 out of bounds for length 10

In dit voorbeeld hebben we een integerarray gemaakt met de naam arr maat 10 .

Aangezien de array-index begint bij 0 , het laatste element van de array is op arr[9] . Let op de verklaring,

arr[10] = 11;

Hier proberen we een waarde toe te kennen aan de index 10 . Vandaar, IndexOutOfBoundException gebeurt.

Wanneer er een uitzondering optreedt in de try blok,

• De uitzondering wordt gegenereerd naar de eerste catch blok. De eerste catch blok verwerkt geen IndexOutOfBoundsException , dus het wordt doorgegeven aan de volgende catch blok.
• De tweede catch blok in het bovenstaande voorbeeld is de juiste uitzonderingshandler omdat het een IndexOutOfBoundsException . afhandelt . Daarom wordt het uitgevoerd.

Meerdere uitzonderingen opvangen

Vanaf Java SE 7 en hoger kunnen we nu meer dan één type uitzondering opvangen met één catch blok.

Dit vermindert codeduplicatie en verhoogt de eenvoud en efficiëntie van de code.

Elk uitzonderingstype dat kan worden afgehandeld door de catch blok wordt gescheiden met een verticale streep | .

De syntaxis is:

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

Ga voor meer informatie naar Java om meerdere uitzonderingen op te vangen.

Java try-with-resources-statement

De try-with-resources statement is een try-statement dat een of meer resourcedeclaraties heeft.

De syntaxis is:

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

De bron is een object dat aan het einde van het programma moet worden afgesloten. Het moet worden gedeclareerd en geïnitialiseerd in het try-statement.

Laten we een voorbeeld nemen.

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

De try-with-resources statement wordt ook wel automatisch resourcebeheer genoemd . Deze verklaring sluit automatisch alle bronnen aan het einde van de verklaring.

Ga voor meer informatie naar de java try-with-resources-verklaring.