Exceptions Java courantes

1. Introduction

Ce didacticiel se concentre sur certaines exceptions Java courantes.

Nous commencerons par discuter de ce qu'est essentiellement une exception. Plus tard, nous discuterons en détail des différents types d'exceptions cochées et non cochées.

2. Exceptions

Une exception est une condition anormale qui se produit dans une séquence de code pendant l'exécution d'un programme. Cette condition anormale survient lorsqu'un programme viole certaines contraintes lors de l'exécution.

Tous les types d'exception sont des sous-classes de la classe Exception . Cette classe est ensuite sous-classée en exceptions vérifiées et en exceptions non vérifiées. Nous les examinerons en détail dans les sections suivantes.

3. Exceptions vérifiées

Les exceptions cochées sont obligatoires à gérer. Ce sont des sous-classes directes de la classe Exception .

Il y a un débat sur leur importance qui vaut la peine d'être examiné.

Définissons en détail quelques exceptions vérifiées.

3.1. IOException

Une méthode lève une IOException ou une sous-classe directe de celle-ci lorsqu'une opération d'entrée / sortie échoue.

Les utilisations typiques de ces opérations d'E / S incluent:

  • Travailler avec le système de fichiers ou les flux de données à l'aide du package java.io
  • Création d'applications réseau à l'aide du package java.net

FileNotFoundException

FileNotFoundException est un type courant d' exception IOException lors de l'utilisation du système de fichiers:

try { new FileReader(new File("/invalid/file/location")); } catch (FileNotFoundException e) { LOGGER.info("FileNotFoundException caught!"); }

MalformedURLException

Lorsque vous travaillez avec des URL, nous pouvons rencontrer une exception MalformedURLException - si nos URL ne sont pas valides.

try { new URL("malformedurl"); } catch (MalformedURLException e) { LOGGER.error("MalformedURLException caught!"); }

3.2. ParseException

Java utilise l'analyse de texte pour créer un objet basé sur une chaîne donnée . Si l'analyse provoque une erreur, elle lève une ParseException .

Par exemple, nous pourrions représenter la date de différentes manières, par exemple jj / mm / aaaa ou jj, mm, aaaa, mais essayez d'analyser une chaîne avec un format différent:

try { new SimpleDateFormat("MM, dd, yyyy").parse("invalid-date"); } catch (ParseException e) { LOGGER.error("ParseException caught!"); }

Ici, la chaîne est mal formée et provoque une ParseException .

3.3. InterruptionException

Chaque fois qu'un thread Java appelle join (), sleep () ou wait (), il passe à l' état WAITING ou TIMED_WAITING .

De plus, un thread peut interrompre un autre thread en appelant la méthode interrupt () d' un autre thread .

Par conséquent, le thread lève une InterruptedException si un autre thread l'interrompt pendant qu'il est dans l'état WAITING ou TIMED_WAITING .

Prenons l'exemple suivant avec deux threads:

  • Le thread principal démarre le thread enfant et l'interrompt
  • Le thread enfant démarre et appelle sleep ()

Ce scénario aboutit à une InterruptedException:

class ChildThread extends Thread { public void run() { try { Thread.sleep(1000); } catch (InterruptedException e) { LOGGER.error("InterruptedException caught!"); } } } public class MainThread { public static void main(String[] args) throws InterruptedException { ChildThread childThread = new ChildThread(); childThread.start(); childThread.interrupt(); } }

4. Exceptions non vérifiées

Pour les exceptions non vérifiées, le compilateur ne vérifie pas pendant le processus de compilation. Par conséquent, il n'est pas obligatoire pour la méthode de gérer ces exceptions.

Toutes les exceptions non vérifiées étendent la classe RuntimeException.

Discutons en détail de certaines exceptions non vérifiées.

4.1. NullPointerException

Si une application tente d'utiliser null là où elle nécessite en fait une instance d'objet, la méthode lèvera une NullPointerException .

Il existe différents scénarios dans lesquels les utilisations illégales de null provoquent une exception NullPointerException. Considérons certains d'entre eux.

Appel d'une méthode de la classe qui n'a pas d'instance d'objet:

String strObj = null; strObj.equals("Hello World"); // throws NullPointerException.

De plus, si une application tente d'accéder ou de modifier une variable d'instance avec une référence nulle , nous obtenons une NullPointerException:

Person personObj = null; String name = personObj.personName; // Accessing the field of a null object personObj.personName = "Jon Doe"; // Modifying the field of a null object

4.2. ArrayIndexOutOfBoundsException

Un tableau stocke ses éléments de manière contiguë. Ainsi, nous pouvons accéder à ses éléments via des index.

Toutefois , si un morceau de code tente d'accéder à un index illégal d'un tableau, la méthode respective lève une ArrayIndexOutOfBoundException.

Voyons quelques exemples qui lancent ArrayIndexOutOfBoundException :

int[] nums = new int[] {1, 2, 3}; int numFromNegativeIndex = nums[-1]; // Trying to access at negative index int numFromGreaterIndex = nums[4]; // Trying to access at greater index int numFromLengthIndex = nums[3]; // Trying to access at index equal to size of the array

4.3. StringIndexOutOfBoundsException

The String class in Java provides the methods to access a particular character of the string or to slice out a character array out of the String. When we use these methods, internally it converts the String into a character array.

Again, there could be an illegal use of indexes on this array. In such cases, these methods of the String class throws the StringIndexOutOfBoundsException.

This exception indicates that the index is either greater than or equal to the size of the String.StringIndexOutOfBoundsException extends IndexOutOfBoundsException.

The method charAt(index) of the class String throws this exception when we try to access a character at the index equal to the String's length or some other illegal index:

String str = "Hello World"; char charAtNegativeIndex = str.charAt(-1); // Trying to access at negative index char charAtLengthIndex = str.charAt(11); // Trying to access at index equal to size of the string 

4.4. NumberFormatException

Quite often an application ends up with numeric data in a String. In order to interpret this data as numeric, Java allows the conversion of String to numeric types. The wrapper classes such as Integer, Float, etc. contains utility methods for this purpose.

However, if the String doesn't have an appropriate format during the conversion, the method throws a NumberFormatException.

Let's consider the following snippet.

Here, we declare a String with an alphanumeric data. Further, we try to use the methods of the Integer wrapper class to interpret this data as numeric.

Consequently, this results in NumberFormatException:

String str = "100ABCD"; int x = Integer.parseInt(str); // Throws NumberFormatException int y = Integer.valueOf(str); //Throws NumberFormatException

4.5. ArithmeticException

When a program evaluates an arithmetic operation and it results in some exceptional condition, it throws ArithmeticException. In addition, ArithmeticException applies to only int and long data types.

For instance, if we try to divide an integer by zero, we get an ArithmeticException:

int illegalOperation = 30/0; // Throws ArithmeticException

4.6. ClassCastException

Java allows typecasting between the objects in order to support inheritance and polymorphism. We can either upcast an object or downcast it.

In upcasting, we cast an object to its supertype. And in downcasting, we cast an object to one of its subtypes.

However, at runtime, if the code attempts to downcast an object to a subtype of which it isn't an instance, the method throws a ClassCastException.

The runtime instance is what actually matters in typecasting. Consider the following inheritance between Animal, Dog, and Lion:

class Animal {} class Dog extends Animal {} class Lion extends Animal {} 

Further, in the driver class, we cast the Animal reference containing an instance of Lion into a Dog.

However, at the runtime, the JVM notices that instance Lion isn't compatible with the subtype of the class Dog.

This results in ClassCastException:

Animal animal = new Lion(); // At runtime the instance is Lion Dog tommy = (Dog) animal; // Throws ClassCastException

4.7. IllegalArgumentException

A method throws an IllegalArgumentException if we call it with some illegal or inappropriate arguments.

For instance, the sleep() method of the Thread class expects positive time and we pass a negative time interval as an argument. This results in IllegalArgumentException:

Thread.currentThread().sleep(-10000); // Throws IllegalArgumentException

4.8. IllegalStateException

IllegalStateException signals that a method's been invoked at an illegal or inappropriate time.

Every Java object has a state (instance variables) and some behavior (methods). Thus, IllegalStateException means it's illegal to invoke the behavior of this object with the current state variables.

However, with some different state variables, it might be legal.

For example, we use an iterator to iterate a list. Whenever we initialize one, it internally sets its state variable lastRet to -1.

With this context, the program tries to call the remove method on the list:

//Initialized with index at -1 Iterator intListIterator = new ArrayList().iterator(); intListIterator.remove(); // IllegalStateException 

Internally, the remove method checks the state variable lastRet and if it is less than 0, it throws IllegalStateException. Here, the variable is still pointing to the value -1.

En conséquence, nous obtenons une IllegalStateException .

5. Conclusion

Dans cet article, nous avons d'abord discuté de ce que sont les exceptions. Une exception est un événement, qui se produit pendant l'exécution d'un programme, qui perturbe le flux normal des instructions du programme.

Ensuite, nous avons classé les exceptions dans les exceptions vérifiées et les exceptions non vérifiées.

Ensuite, nous avons discuté des différents types d'exceptions qui peuvent survenir pendant la compilation ou lors de l'exécution.

Nous pouvons trouver le code de cet article sur GitHub.