Les erreurs d'exécution Java les plus courantes

Feb 27 2023

Les erreurs d'exécution se produisent lorsqu'un programme ne contient aucune erreur de syntaxe mais demande à l'ordinateur de faire quelque chose que l'ordinateur est incapable de faire de manière fiable. Lors de la compilation, le compilateur n'a aucune technique pour détecter ce genre d'erreurs.

Les erreurs d'exécution se produisent lorsqu'un programme ne contient aucune erreur de syntaxe mais demande à l'ordinateur de faire quelque chose que l'ordinateur est incapable de faire de manière fiable . Lors de la compilation, le compilateur n'a aucune technique pour détecter ce genre d'erreurs. C'est la JVM (Java Virtual Machine) qui le détecte pendant l'exécution du programme.

· Exception StackOverflowError
· Exception OutOfMemoryError
· NegativeArraySizeException
· ArithmeticException
· ArrayIndexOutOfBoundsException
· ArrayStoreException
· UnsupportedOperationException
· NoSuchElementException
· ClassCastException
· DateTimeException
· ConcurrentModificationException
· InputMismatchException
· IllegalFormatConversionException
· NumberFormatException
· InvalidParameterException
· NullPointerException

Exception StackOverflowError

StackOverflowError est une erreur que Java ne permet pas d'attraper, par exemple, la pile manque d'espace, car c'est l'une des erreurs d'exécution les plus courantes que l'on puisse rencontrer.

La cause principale de StackOverflowError est que nous n'avons pas fourni la condition de fin appropriée à notre fonction ou modèle récursif, ce qui signifie qu'elle se transformera en une boucle infinie . Donc, cette erreur est générée lorsque Java manque de mémoire disponible.

// Java program to demonstrate
// infinite recursion error
public class StackOverflowErrorClass {
 static int i = 0;
 // Method to print numbers
 public static int printNumber(int x)
 {
  i = i + 2;
  System.out.println(i);
  return i + printNumber(i + 2);
 }
 public static void main(String[] args)
 {
  // Recursive call without any
  // terminating condition
  StackOverflowErrorClass.printNumber(i);
 }
}

RunTime Error in java code :- Exception in thread “main” java.lang.StackOverflowError
at java.io.PrintStream.write(PrintStream.java:526)
at java.io.PrintStream.print(PrintStream.java:597)
at java.io.PrintStream.println(PrintStream.java:736)
at StackOverflowErrorClass.printNumber(StackOverflowErrorClass.java:13)
at StackOverflowErrorClass.printNumber(StackOverflowErrorClass.java:14)
at StackOverflowErrorClass.printNumber(StackOverflowErrorClass.java:14)
.
.
.

Exception OutOfMemoryError

Erreur d'espace/mémoire insuffisant (java.lang.OutOfMemoryError) dans les threads

Une java.lang.OutOfMemoryError est une erreur d'exécution dans Java qui se produit lorsque la machine virtuelle Java ( JVM ) est incapable d'allouer un objet en raison d'un espace insuffisant dans le tas Java. Le Java Garbage Collector ( GC ) ne peut pas libérer l'espace requis pour un nouvel objet, ce qui provoque une erreur java.lang.OutOfMemoryError . Cette erreur peut également être générée lorsque la mémoire native est insuffisante pour supporter le chargement d'une classe Java.

Voici un exemple de levée en raison d'un espace insuffisant dans le tas Java :

public class OutOfMemoryErrorExample {
    public static void main(String[] args) {
        Integer[] myArray = new Integer[1000 * 1000 * 1000];
    }
}

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    at OutOfMemoryErrorExample.main(OutOfMemoryErrorExample.java:8)

NegativeArraySizeExceptionNegativeArraySizeException

La NegativeArraySizeException est une exception d'exécution en Java qui se produit lorsqu'une application tente de créer un tableau avec une taille négative . Étant donné que NegativeArraySizeException est une exception non vérifiée (étend RuntimeException ), il n'est pas nécessaire de la déclarer dans la clause throws d'une méthode ou d'un constructeur.

Les développeurs doivent définir la taille du tableau sur un entier positif. Si un signe moins se glisse dans la déclaration de taille de tableau, cela lève l'exception NegativeArraySizeException.

class JavaError {
public static void main(String[] args) {
    int[] arr = new int[-5]; // Negative size of the array
    arr[8] = 89;
    System.out.println("Something went wrong!");
  }
}

java -cp /tmp/UDRgGsLLQ6 JavaError
Exception in thread "main" java.lang.NegativeArraySizeException: -5
at JavaError.main(JavaError.java:4)

ArithmeticException

ex. diviser par zéro les erreurs

La manipulation des données est une fonction principale de la plupart des applications Java. Lorsque la manipulation de données inclut la division, les développeurs doivent se méfier de la division par zéro . Si jamais zéro devient le dénominateur dans un calcul, Java lève une ArithmeticException. Nous ne pouvons donc rien diviser à partir de zéro, donc lorsque nous essayons de le faire, nous obtenons une exception arithmétique au moment de l'exécution.

class JavaError {
public static void main(String[] args) {
    int a = 23;
    int b = 0;
    System.out.println(a / b);
  }
}

java -cp /tmp/UDRgGsLLQ6 JavaError
Exception in thread "main" java.lang.ArithmeticException: / by zeroat JavaError.main(JavaError.java:7)

ArrayIndexOutOfBoundsExceptionArrayIndexOutOfBoundsException

lorsqu'un élément inexistant dans un tableau est accédé

Un tableau en Java nécessite une taille définie. Si vous essayez d'ajouter plus d'éléments que le tableau ne peut en contenir, cela entraînera l' exception ArrayIndexOutOfBoundsException . Le code suivant tente d'ajouter un élément au huitième index d'un tableau qui a été construit pour ne contenir que cinq éléments :

Accéder à un index de tableau qui n'existe pas :

class JavaError {
public static void main(String[] args) {
    String[] arr = new String[5];
    arr[6] = "Hi"; // Accessing array index that does not exsist
    System.out.println("Something went wrong!");
  }
}

java -cp /tmp/UDRgGsLLQ6 JavaError
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 6 out of bounds for length 5
at JavaError.main(JavaError.java:6)

Java applique un comptage basé sur zéro aux éléments d'un tableau, de sorte que l'index 6 d'un tableau ferait référence au septième élément. Même le code suivant déclencherait une ArrayIndexOutOfBoundsException en Java, car l'index 4 est une référence au cinquième élément d'un tableau :

String[] arr = new String[5];
arr[5] = "Hi"; // Accessing array index that does not exsist

ArrayStoreException

ArrayStoreException partage des similitudes avec ClassCastException. Cette exception d'exécution Java se produit lorsque le mauvais type d'objet est placé dans un tableau.

Dans l'exemple ci-dessous, un tableau BigInteger est créé, suivi d'une tentative d'ajout d'un Double. Le Double ne partage pas de relation avec le BigInteger, cela déclenche donc une ArrayStoreException au moment de l'exécution.

Number[] bigInt = new BigInteger[5];
bigInt[0] = Double.valueOf(12345);

BigInteger[] bigInt = new BigInteger[5];
bigInt[0] = Double.valueOf(12345); // Java compile error

UnsupportedOperationExceptionUnsupportedOperationExceptionUnsupportedOperationExceptionUnsupportedOperationExceptionUnsupportedOperationException

Les programmeurs Java utilisent souvent la classe Arrays pour transformer un tableau Java en une liste plus conviviale. Cependant, la liste renvoyée par Java est en lecture seule. Les développeurs qui ne sont pas conscients de ce fait et essaient d'ajouter de nouveaux éléments se heurtent à l'exception UnsupportedOperationException. Cet exemple montre comment cela se produit :

Integer[] data = {1,2,3,5,8,13,21};
List<Integer> list = Arrays.asList(data);
list.add(new Integer(0));

NoSuchElementException

Vous ne pouvez pas parcourir un itérateur vide. Le code suivant, qui tente d'obtenir l'élément suivant dans un HashSet vide, lève une NoSuchElementException.

Set set = new HashSet();
set.iterator().next(); // Java runtime exception thrown

if (!set.isEmpty()) {
  set.iterator().next();
}

pour les erreurs de conversion de type de données

Java est un langage fortement typé. Il applique strictement les hiérarchies de types et ne convertira pas un objet en un autre à moins qu'ils ne partagent une relation polymorphe. Ainsi, ClassCastException se produit lorsque vous essayez de convertir à tort un objet en une classe particulière. Cela signifie que votre objet n'est pas une instance ou une sous-classe de cette classe.

Dans le code suivant, la tentative de conversion de l'objet Date en un Timestamp génère une erreur ClassCastException lors de l'exécution.

Date today = new Date();Timestamp time = (Timestamp)today;

long seconds = System.currentTimeMillis();
Timestamp time = new Timestamp(seconds);
Date today = (Date)time; // this cast works

DateTimeException

La manipulation des données est une entreprise délicate. Les fuseaux horaires, les dates et les formats de date incohérents peuvent amener Java à lancer diverses exceptions DateTimeExceptions lors de l'exécution.

Par exemple, le code suivant est compilé, mais le champ HourOfDay de la classe LocalDate entraînera l'échec de la tentative de formatage de la date.

LocalDate now = LocalDate.now();
DateTimeFormatter.RFC_1123_DATE_TIME.format(now);

LocalDate now = LocalDate.now();
DateTimeFormatter.ISO_DATE.format(now);

pour les calculs parallèles mal implémentés

La méthode asList de la classe Arrays n'est pas la seule fois où une collection nécessite le traitement en lecture seule.

Lorsque vous parcourez une liste, la collection sous-jacente doit être fixe et non mise à jour. Ainsi, la méthode add dans l'extrait de code suivant lève une ConcurrentModificationException.

List servers = new ArrayList();
servers.add("Tomcat");
                   
Iterator<String> iterator = servers.iterator();
while (iterator.hasNext()) {
  String server = iterator.next();
  servers.add("Jetty");  // throws a Runtime Exception
}

InputMismatchException

l' exception InputMismatchException se produit généralement lorsque vous travaillez avec des programmes Java qui invitent les utilisateurs à saisir des données à l'aide de la classe Scanner . Cette exception est généralement causée lors de la saisie de l'utilisateur lorsque vous attendez un certain type de saisie et que l'utilisateur saisit un autre type de saisie. En d'autres termes, cette exception peut se produire lorsque l'entrée n'est pas valide pour le type attendu. L'entrée ne correspond pas au modèle pour le type attendu ou est hors plage.

Comme transmettre des données non valides, par exemple en transmettant une valeur numérique au champ non numérique. Par exemple, si un programme attend une valeur Integer pour une entrée mais que l'utilisateur entre une valeur String à la place, une InputMismatchException est levée.

Solution : Enveloppez le code qui demande une entrée utilisateur dans une boucle while qui demandera en permanence à l'utilisateur une entrée correcte.

IllegalFormatConversionExceptionIllegalFormatConversionException

Explication : Ceci est associé à printf() et String.format() . Cela signifie qu'il y a un espace réservé non associé (trop d'espaces réservés, pas assez d'arguments) ou que c'est le mauvais espace réservé pour le type dans les arguments. Par exemple, un %s étant un espace réservé pour un entier générera cette erreur.

Solution : assurez-vous que le nombre d'espaces réservés correspond au nombre d'arguments et assurez-vous que les espaces réservés sont du type correct.

NumberFormatException

Tentative de conversion d'une chaîne invalide en nombre

L' exception NumberFormatException se produit lorsqu'une tentative est faite pour convertir une chaîne avec un format incorrect en une valeur numérique. Cela signifie que lorsqu'il n'est pas possible de convertir une chaîne dans n'importe quel type numérique (float, int, etc.), cette exception est levée. Il s'agit d'une exception d'exécution (exception non contrôlée) en Java. C'est une sous-classe de la classe IllegalArgumentException .

ExceptionParamètreInvalide

Passer des paramètres/arguments invalides à une méthode

Cette exception, une sous-classe de IllegalArgumentException conçue pour être utilisée par les classes du moteur JCA/JCE, est levée lorsqu'un paramètre non valide est passé à une méthode .

NullPointerException

NullPointerException est une RuntimeException très courante rencontrée par les applications Java. cette exception est levée lorsque Java rencontre une référence null alors qu'il n'en attend pas. et un développeur java écrit du code qui invoque une méthode sur cette référence (objet non initialisé).

String data = null;
System.out.println( data.length() ); // throws NullPointerException

Pour éviter cette RuntimeException dans vos programmes Java, initialisez chaque objet que vous créez avant de l'utiliser et effectuez une vérification nulle sur tout objet qu'une bibliothèque externe transmet à vos programmes.