Java essayer ... attraper

Java essaie... attrape

Dans ce didacticiel, nous allons découvrir l'instruction try catch en Java à l'aide d'exemples.

Le try...catch block en Java est utilisé pour gérer les exceptions et empêche l'arrêt anormal du programme.

Voici la syntaxe d'un try...catch bloquer en Java.

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

Le try bloc inclut le code susceptible de générer une exception.

Le catch bloc inclut le code qui est exécuté lorsqu'il se produit une exception à l'intérieur du try bloquer.

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

Sortie

ArithmeticException => / by zero

Dans l'exemple ci-dessus, notez la ligne,

int divideByZero = 5 / 0;

Ici, nous essayons de diviser un nombre par zéro . Dans ce cas, une exception se produit. Par conséquent, nous avons inclus ce code dans le try bloquer.

Lorsque le programme rencontre ce code, ArithmeticException se produit. Et, l'exception est interceptée par le catch bloque et exécute le code à l'intérieur du catch bloquer.

Le catch le bloc n'est exécuté que s'il existe une exception dans le try bloquer.

Remarque :En Java, on peut utiliser un try bloquer sans catch bloquer. Cependant, nous ne pouvons pas utiliser un catch bloquer sans try bloquer.

Java essaie... enfin bloque

On peut aussi utiliser le try bloquer avec un bloc finally.

Dans ce cas, le bloc finally est toujours exécuté, qu'il y ait ou non une exception à l'intérieur du bloc try.

Exemple :Java essaie... enfin bloque

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

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

Sortie

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

Dans l'exemple ci-dessus, nous avons utilisé le try bloc avec le finally bloquer. Nous pouvons voir que le code à l'intérieur du try le bloc provoque une exception.

Cependant, le code à l'intérieur du finally bloc est exécuté indépendamment de l'exception.

Java essaie...attrape...bloque finalement

En Java, on peut aussi utiliser le bloc finally après le try...catch bloquer. Par exemple,

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

Sortie

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

Dans l'exemple ci-dessus, nous avons créé un tableau nommé list et un fichier nommé output.txt . Ici, nous essayons de lire les données du tableau et de les stocker dans le fichier.

Remarquez le code,

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

Ici, la taille du tableau est 5 et le dernier élément du tableau est à list[4] . Cependant, nous essayons d'accéder aux éléments à a[5] et a[6] .

Par conséquent, le code génère une exception qui est interceptée par le bloc catch.

Depuis le finally bloc est toujours exécuté, nous avons inclus du code pour fermer le PrintWriter à l'intérieur du bloc finally.

Il est recommandé d'utiliser le bloc finally pour inclure un code de nettoyage important, comme la fermeture d'un fichier ou d'une connexion.

Remarque :Il y a des cas où un finally le bloc ne s'exécute pas :

Utilisation de System.exit() méthode
Une exception se produit dans le finally bloquer
La mort d'un fil

Blocs Catch multiples

Pour chaque try bloc, il peut y avoir zéro ou plusieurs catch blocs. Plusieurs catch les blocs nous permettent de gérer chaque exception différemment.

Le type d'argument de chaque catch block indique le type d'exception qu'il peut gérer. Par exemple,

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

Sortie

IndexOutOfBoundsException => Index 10 out of bounds for length 10

Dans cet exemple, nous avons créé un tableau d'entiers nommé arr de taille 10 .

Étant donné que l'index du tableau commence à partir de 0 , le dernier élément du tableau est à arr[9] . Remarquez la déclaration,

arr[10] = 11;

Ici, on essaie d'attribuer une valeur à l'indice 10 . Par conséquent, IndexOutOfBoundException se produit.

Lorsqu'une exception se produit dans le try bloquer,

L'exception est levée au premier catch bloquer. Le premier catch le bloc ne gère pas un IndexOutOfBoundsException , il est donc passé au catch suivant bloquer.
Le deuxième catch block dans l'exemple ci-dessus est le gestionnaire d'exception approprié car il gère un IndexOutOfBoundsException . Par conséquent, il est exécuté.

Récupérer plusieurs exceptions

À partir de Java SE 7 et versions ultérieures, nous pouvons désormais intercepter plusieurs types d'exceptions avec un seul catch bloquer.

Cela réduit la duplication de code et augmente la simplicité et l'efficacité du code.

Chaque type d'exception pouvant être géré par le catch le bloc est séparé par une barre verticale | .

Sa syntaxe est :

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

Pour en savoir plus, consultez Java interceptant plusieurs exceptions.

Instruction Java try-with-resources

Le essayer avec des ressources instruction est une instruction try qui a une ou plusieurs déclarations de ressource.

Sa syntaxe est :

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

La ressource est un objet à fermer à la fin du programme. Il doit être déclaré et initialisé dans l'instruction try.

Prenons un exemple.

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

Le essayer avec des ressources déclaration est également appelée gestion automatique des ressources . Cette instruction ferme automatiquement toutes les ressources à la fin de l'instruction.

Pour en savoir plus, consultez la déclaration java try-with-resources.

Gestion des exceptions Java Java lancer et lancer

Java