Programme Java qui gère les méthodes d'exception

Exception est un événement anormal qui perturbe le flux d'exécution normal d'un programme. Lorsqu'une exception se produit, un objet appelé objet d'exception est généré, qui contient les détails de l'exception tels que le nom, la description et l'état du programme. Dans cette section, nous allons écrire un programme Java pour gérer les différentes méthodes d'exception présentes en Java.

Type d'exception

Il existe trois types d'exceptions −

Exception vérifiée - Les exceptions vérifiées sont des exceptions au moment de la compilation, qui sont vérifiées lors de la compilation du programme. Ces exceptions ne peuvent être ignorées et doivent être gérées par le programmeur. Par exemple : IOException, SQLException, ClassNotFounException.

Exceptions non vérifiées - Les exceptions non vérifiées sont des exceptions d'exécution, c'est-à-dire qu'elles sont ignorées lors de la compilation et vérifiées lors de l'exécution du programme. Par exemple : NullPointerException (exception de pointeur nul), ArithmeticException (exception arithmétique) et ArrayIndexOutOfBoundsException (exception hors limites du tableau).

Erreurs - Les erreurs sont des exceptions irrécupérables qui se produisent généralement en raison de problèmes avec la machine virtuelle Java ou les ressources système. Les erreurs, contrairement aux exceptions, ne doivent pas être détectées ou traitées par les programmeurs, car elles nous indiquent qu'il existe un problème grave qui ne peut pas être résolu par le programme. Par exemple : OutOfMemoryError, StackOverflowError.

Gestion des exceptions

La

Gestion des exceptions est le processus de gestion des exceptions levées lors de l'exécution du programme afin que le flux d'exécution ne soit pas interrompu. Cela se fait à l'aide de blocs try-catch en Java. Le bloc try contient du code qui peut générer des exceptions, et le bloc catch contient du code qui gère les exceptions.

Nous pouvons utiliser des exceptions intégrées ou créer des exceptions personnalisées ou définies par l'utilisateur. Les exceptions personnalisées étendent la classe Exception ou la classe RuntimeException.

Java propose de nombreuses méthodes pour gérer ces exceptions. Certaines de ces méthodes sont -

getMessage() - Cette méthode est utilisée pour renvoyer le message d'erreur sous forme de chaîne. Il s'agit d'une méthode définie dans la classe Throwable en Java.

try {
   // some code that may throw an exception
} catch (Exception e) {
   String message = e.getMessage();
   System.out.println("Exception occurred: " + message);

getStackTrace() - Cette méthode renvoie un tableau de la séquence d'appels de méthode qui a provoqué l'exception. Il s'agit de la méthode définie dans la classe Throwable en Java.

try {
   // some code that may throw an exception
} catch (Exception e) {
   StackTraceElement[] st = e.getStackTrace();
   for (StackTraceElement ele : st) {
      System.out.println(ele.toString());
   }
}

printStackTrace() - Cette méthode imprime un tableau de la séquence d'appels de méthode qui a provoqué l'exception. Il s'agit de la méthode définie dans la classe Throwable en Java.

try {
   // some code that may throw an exception
} catch (Exception e) {
   e.printStackTrace();
}

Throw - 'throw' est le mot-clé en Java pour lancer explicitement des exceptions. Lorsque ce mot-clé est exécuté, le flux normal du programme sera arrêté et il lèvera une exception, qui sera interceptée par l'instruction catch la plus proche.

public void divide(int a, int b) {
   if (b == 0) {
      throw new ArithmeticException("Cannot divide by zero!"); // throws Arthemetic Exception
   }
   int result = a / b;
   System.out.println("Result: " + result);
}

getCause() - Cette méthode renvoie la cause des autres exceptions qui ont déclenché cette exception. Si la cause est inconnue, « null » est renvoyé. Il s'agit d'une méthode définie dans la classe Throwable en Java.

try {
   // some code that may throw an exception
} catch (Exception e) {
   Throwable cause = e.getCause();
   if (cause != null) {
      System.out.println("Cause: " + cause.toString());
   } else {
      System.out.println("No cause found.");
   }
}

Grammaire

bloc try-catch - le bloc try-catch en Java est utilisé pour gérer les exceptions. Le bloc try contient du code qui peut lever une exception. Le bloc catch intercepte les exceptions et les gère. Une tentative peut être suivie d'un ensemble de blocs catch.

try {
   // Protected code
} catch (ExceptionName e1) {
   // Catch block
}

Nous allons maintenant discuter en détail des différentes manières de gérer les exceptions de méthode en Java.

Méthode 1 : utilisez un seul bloc try-catch

Dans cette approche, nous utiliserons un seul bloc try et un seul bloc catch pour gérer l'exception qui se produit.

Algorithme

• Initialisez un tableau avec des valeurs aléatoires.

• Essayez d'accéder aux éléments du tableau de telle sorte que l'index soit supérieur à la longueur du tableau. Mettez ce code dans un bloc try car il lèvera une exception.

• Une fois qu'une exception se produit, utilisez la méthode catch() pour intercepter l'exception ArrayIndexOutOfBounds, utilisez la méthode getMessage() pour imprimer le message, et utilisez la méthode printStackTrace() pour imprimer la séquence d'appels de méthode.

Exemple

Dans cet exemple, nous écrivons le code dans des blocs try and catch. Dans le bloc try, nous initialisons un tableau avec 5 valeurs et accédons au 8ème élément du tableau, qui lève généralement une exception "ArrayIndexOutOfBoundsException" . Le bloc catch intercepte cette exception et imprime le message d'erreur à l'aide de la méthode getMessage(), et la méthode printStackTrace() est utilisée pour imprimer la séquence d'appel de méthode lorsque l'exception se produit.

import java.util.*;
public class Main {
   public static void main(String[] args) {
      try {
         int[] arr = {1, 2, 3,4,5};
         System.out.println(arr[8]); 
      } catch (ArrayIndexOutOfBoundsException e) {
         System.out.println("An exception occurred: " + e.getMessage());
         e. printStackTrace() ;

      }
   }
}

Sortie

An exception occurred: Index 8 out of bounds for length 5
java.lang.ArrayIndexOutOfBoundsException: Index 8 out of bounds for length 5
        at Main.main(Main.java:6)

Méthode 2 : utilisez un seul bloc try et plusieurs blocs catch

Dans cette approche, nous utiliserons un seul bloc try et plusieurs blocs catch pour gérer les exceptions qui se produisent.

Algorithme

• Déclarez un bloc try et initialisez deux variables entières, à savoir le numérateur et le dénominateur. La variable dénominateur est initialisée à 0.

• Maintenant, si la valeur du dénominateur est égale à 0, une ArithmeticException est levée.

• Écrivez plusieurs blocs catch pour gérer différentes exceptions.

• Utilisez différentes méthodes intégrées dans Java et imprimez le message d'exception et l'exception survenue.

示例

在此示例中，我们使用了一个 try 块，后跟多个 catch 块。如果从 try 块中抛出 ArithmeticException，则执行处理 ArithmeticException 代码的 catch 块。如果 try 块抛出 NullPointerException，则执行该特定的 catch 块。如果 catch 块不处理 try 块引发的特定异常，则执行最后一个 catch 块代码，因为它正在处理通用异常情况。从示例中，当分母值初始化为零时，我们使用“throw”关键字抛出一个 ArthemeticException，并执行处理 ArthemeticException 的 catch 块。

import java.util.*;
public class Main {
   public static void main(String[] args) {
      try {
         int numerator = 10, denominator = 0 ;
         if(denominator == 0) {
            throw new ArithmeticException();
         }
      } catch (ArithmeticException e) {
         System.out.println("ArithmeticException caught.");
         System.out.println("Message: " + e.getMessage());
         System.out.println("Stack Trace: ");
         e.printStackTrace();
         System.out.println("Cause: " + e.getCause());
      } catch (NullPointerException e) {
         System.out.println("NullPointerException caught.");
         System.out.println("Message: " + e.getMessage());
         System.out.println("Stack Trace: ");
         e.printStackTrace();
         System.out.println("Cause: " + e.getCause());
      } catch (ArrayIndexOutOfBoundsException e) {
         System.out.println("ArrayIndexOutOfBoundsException caught.");
         System.out.println("Message: " + e.getMessage());
         System.out.println("Stack Trace: ");
         e.printStackTrace();
         System.out.println("Cause: " + e.getCause());
      }catch (Exception e) {
         System.out.println("NullPointerException caught.");
         System.out.println("Message: " + e.getMessage());
         System.out.println("Stack Trace: ");
         e.printStackTrace();
         System.out.println("Cause: " + e.getCause());
      }
   }
}

输出

ArithmeticException caught.
Message: null
Stack Trace: 
java.lang.ArithmeticException
        at Main.main(Main.java:7)
Cause: null

因此，在本文中，我们讨论了处理Java编程语言中异常方法的不同方法。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!