Gestion des exceptions Java

Dans le didacticiel, nous découvrirons différentes approches de la gestion des exceptions en Java à l'aide d'exemples.

Dans le dernier tutoriel, nous avons découvert les exceptions Java. Nous savons que les exceptions terminent anormalement l'exécution d'un programme.

C'est pourquoi il est important de gérer les exceptions. Voici une liste des différentes approches pour gérer les exceptions en Java.

Essayez... attrapez le bloc
bloquer enfin
lancer et lancer le mot-clé

1. Java try...catch block

Le bloc try-catch est utilisé pour gérer les exceptions en Java. Voici la syntaxe de try...catch bloquer :

try {
  // code
}
catch(Exception e) {
  // code
}

Ici, nous avons placé le code qui pourrait générer une exception à l'intérieur du try bloquer. Tous les try bloc est suivi d'un catch bloquer.

Lorsqu'une exception se produit, elle est interceptée par le catch bloquer. Le catch le bloc ne peut pas être utilisé sans le try bloquer.

Exemple :gestion des exceptions à l'aide de try...catch

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

    try {

      // code that generate exception
      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, nous essayons de diviser un nombre par 0 . Ici, ce code génère une exception.

Pour gérer l'exception, nous avons mis le code, 5 / 0 à l'intérieur du try bloquer. Désormais, lorsqu'une exception se produit, le reste du code à l'intérieur du try bloc est ignoré.

Le catch capture l'exception et les instructions à l'intérieur du bloc catch sont exécutées.

Si aucune des déclarations dans le try le bloc génère une exception, le catch bloc est ignoré.

2. Java finit par bloquer

En Java, le finally bloc est toujours exécuté, qu'il y ait une exception ou non.

Le finally bloc est facultatif. Et, pour chaque try bloc, il ne peut y avoir qu'un seul finally bloquer.

La syntaxe de base de finally bloc est :

try {
  //code
}
catch (ExceptionType1 e1) { 
  // catch block
}
finally {
  // finally block always executes
}

Si une exception se produit, le finally le bloc est exécuté après le try...catch bloquer. Sinon, il est exécuté après le bloc try. Pour chaque try bloc, il ne peut y avoir qu'un seul finally bloquer.

Exemple :gestion des exceptions Java à l'aide du bloc finally

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

    catch (ArithmeticException e) {
      System.out.println("ArithmeticException => " + e.getMessage());
    }
    
    finally {
      System.out.println("This is the finally block");
    }
  }
}

Sortie

ArithmeticException => / by zero
This is the finally block

Dans l'exemple ci-dessus, nous divisons un nombre par 0 à l'intérieur du try bloquer. Ici, ce code génère un ArithmeticException .

L'exception est interceptée par le catch bloquer. Et puis le finally bloc est exécuté.

Remarque :Il est recommandé d'utiliser le finally bloquer. C'est parce qu'il peut inclure des codes de nettoyage importants comme,

code qui pourrait être accidentellement ignoré par return, continue ou break
fermer un fichier ou une connexion

3. Mot-clé Java throw et throws

Le Java throw mot-clé est utilisé pour lever explicitement une seule exception.

Lorsque nous throw une exception, le déroulement du programme passe du try bloc au catch bloquer.

Exemple :gestion des exceptions à l'aide de Java throw

class Main {
  public static void divideByZero() {

    // throw an exception
    throw new ArithmeticException("Trying to divide by 0");
  }

  public static void main(String[] args) {
    divideByZero();
  }
}

Sortie

Exception in thread "main" java.lang.ArithmeticException: Trying to divide by 0
        at Main.divideByZero(Main.java:5)
        at Main.main(Main.java:9)

Dans l'exemple ci-dessus, nous lançons explicitement le ArithmeticException en utilisant le throw mot-clé.

De même, le throws Le mot-clé est utilisé pour déclarer le type d'exceptions pouvant se produire dans la méthode. Il est utilisé dans la déclaration de méthode.

Exemple :Java lance un mot-clé

import java.io.*;

class Main {
  // declareing the type of exception
  public static void findFile() throws IOException {

    // code that may generate IOException
    File newFile = new File("test.txt");
    FileInputStream stream = new FileInputStream(newFile);
  }

  public static void main(String[] args) {
    try {
      findFile();
    }
    catch (IOException e) {
      System.out.println(e);
    }
  }
}

Sortie

java.io.FileNotFoundException: test.txt (The system cannot find the file specified)

Lorsque nous exécutons ce programme, si le fichier test.txt n'existe pas, FileInputStream lance un FileNotFoundException qui étend le IOException classe.

Le findFile() spécifie qu'un IOException peut être jeté. Le main() method appelle cette méthode et gère l'exception si elle est levée.

Si une méthode ne gère pas les exceptions, le type d'exceptions qui peuvent se produire en son sein doit être spécifié dans le throws clause.

Pour en savoir plus, visitez Lancer et lancers Java.

Exception Java Java essayer ... attraper

Java