Java Essayer - Attraper

Des erreurs peuvent survenir lors de l'exécution du programme. C'est un problème commun à tous les programmeurs, du débutant au vrai pro. Toutes les erreurs ne sont pas dues à la faute du développeur. Certains d’entre eux sont difficiles à prévoir, et parfois ce n’est pas possible. Par exemple, lors du téléchargement d'un programme, la connexion réseau peut soudainement s'interrompre ou l'alimentation peut être coupée. De telles situations sont appelées exceptions. Try and catch sont les parties de construction utilisées pour gérer les exceptions.

Java essayer et attraper le bloc

Lorsqu'une erreur se produit, Java s'arrête généralement et génère un message d'erreur. Ce processus est appelé « Java lève une exception ». Java fournit des fonctionnalités spéciales pour gérer les exceptions. L’un d’eux est d’essayer… d’attraper… enfin de construire. Voici la syntaxe du bloc try, du bloc catch et enfin du bloc.

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

Lorsqu'une exception se produit dans le bloc try, le contrôle passe au bloc catch, qui peut gérer l'exception. Si aucun bloc de ce type n'est trouvé, un message d'exception non géré est affiché à l'utilisateur et la poursuite de l'exécution du programme est arrêtée. C'est pour éviter un tel arrêt d'urgence qu'il faut utiliser le bloc try..catch.

En bref sur essayer, attraper, enfin, lancer des mots-clés

La gestion des exceptions en Java repose sur l'utilisation des mots-clés suivants dans un programme :

• try — définit un bloc de code dans lequel une exception peut se produire ;
• catch — définit le bloc de code dans lequel l'exception est gérée ;
• enfin — définit un bloc de code facultatif, mais s'il est présent, il est quand même exécuté, quels que soient les résultats du bloc try.

Ces mots-clés sont utilisés pour créer des constructions de traitement spéciales dans le code du programme : try catch et try catchfinal}.

• throw — utilisé pour déclencher une exception ;
• throws — utilisé dans les signatures de méthode pour avertir qu'une méthode pourrait lever une exception.

Exemple simple de construction try-catch

Disons que nous avons un programme avec un tableau.

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

Puisque nous essayons d'accéder à un élément du tableau avec un index inexistant, le programme se terminera avec une erreur : Modifions ce programme et gérons cette exception avec un try-catch. Vient d’abord le bloc try, plus tard le bloc catch.

//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...");
   }
}

Maintenant, le résultat a changé : Dans ce cas, le programme s'est terminé correctement, notre message s'affiche à l'écran. La fin correcte du programme est signalée par le code 0 à la fin du processus, tandis qu'incorrect — 1. Lors de l'utilisation d'un bloc try...catch, toutes les instructions entre les instructions try et catch sont exécutées en premier. Si une exception se produit dans le bloc try, l'ordre d'exécution normal s'arrête et passe à l'instruction catch. Par conséquent, lorsque l'exécution du programme atteint les nombres[7]=8; ligne, le programme s'arrêtera et ira au bloc catch. Dans notre cas, nous avons déclaré la variable myEx avec le type Exception. Il s'agit de la classe de base pour toutes les exceptions, elles peuvent donc être différentes. Par exemple, il existe des exceptions qui sont responsables de débordements de pile, allant au-delà de l'indexation du tableau, comme dans notre cas, pointant vers Null, etc. Si nous n'avions pas deviné le type d'exception, le programme se serait également terminé de manière incorrecte. Cependant, nous avons choisi le type Exception pour la simplicité de l'exemple, et c'est la classe de base pour toutes les exceptions. Ainsi, l'instruction catch (Exception myEx) gérera presque toutes les exceptions. Gestion de l'exception dans ce cas Une fois le bloc catch terminé, le programme continue son travail, exécutant toutes les autres instructions après le bloc catch. Si vous souhaitez voir les exceptions survenues, vous pouvez demander au programme d'imprimer une trace de pile des appels de méthode. C'est ce que fait la JVM lorsqu'une exception non interceptée se produit : elle arrête l'exécution du programme et imprime une trace de pile après avoir exécuté le code du bloc final, s'il est présent.

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...");
   }
}

La gestion de l'exception dans ce cas revient à imprimer la pile de trace d'erreur sur la console à l'aide de la méthode printStackTrace() définie dans la classe Exception . Cependant, le programme s'est terminé correctement.

Enfin! Après avoir attrapé

Dans l'exemple et dans les définitions des mots clés pour la gestion des exceptions, nous avons mentionné le bloc enfin. Il est facultatif, mais s'il est présent, il sera exécuté quels que soient les résultats du bloc try. Changeons le type d'exception en 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...");
   }
}

Voici le résultat : À propos, nous pouvons spécifier le type d'exception qui est correct. Ici, c'est 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...");
   }
}

Dans ce cas, le résultat sera le suivant :

Comment fonctionnent les exceptions ?

Le fait est que tous ces mots - attraper, lancer, lancer ne peuvent être utilisés qu'avec java.lang.Throwable ou ses descendants. Par exemple, vous pouvez faire ceci :

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

Cependant, vous ne pouvez pas procéder ainsi :

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