TOC

Exceptions Java communes

Exceptions Java communes

1. introduction

Ce tutoriel se concentre sur certaines exceptions Java courantes.

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

2. Exceptions

An exception is an abnormal condition that occurs in a code sequence during the execution of a program. 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 classeException. Cette classe est ensuite subdivisée en exceptions vérifiées et exceptions non vérifiées. Nous les examinerons en détail dans les sections suivantes.

3. Exceptions vérifiées

Checked exceptions are mandatory to handle. Ce sont des sous-classes directes de la classeException.

Il y a undebate sur leur importance qui mérite d'être examiné.

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

3.1. IOException

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

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

  • Utilisation du système de fichiers ou des flux de données à l’aide du packagejava.io

  • Création d'applications réseau à l'aide du packagejava.net

FileNotFoundException

FileNotFoundException est un type courant deIOException lorsque vous travaillez avec le 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 rencontrerMalformedURLException –  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 unString.If parsing causes an error, it throws a ParseException. donné

Par exemple, nous pourrions représenterDate de différentes manières, par exemple dd/mm/yyyy oudd,mm,yyyy, mais essayez d'analyser unstring avec un format différent: 

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

Ici, leString est mal formé et provoque unParseException.

3.3. InterruptedException

Chaque fois qu'un thread Java appellejoin(), sleep() ouwait(), il passe soit à l'étatWAITING, soit à l'étatTIMED_WAITING.

De plus, un thread peut interrompre un autre thread en appelant la méthodeinterrupt() d’un autre thread.

Par conséquent,the thread throws an InterruptedException if another thread interrupts it while it is in the WAITING or in the TIMED_WAITING state.

Considérez l'exemple suivant avec deux threads:

  • Le thread principal démarre le thread enfant et l'interrompt

  • Le thread enfant démarre et appellesleep()

Ce scénario aboutit à unInterruptedException: 

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 contrôlées

For Unchecked Exceptions, the compiler doesn’t check during the compilation process. Par conséquent, il n’est pas obligatoire que la méthode gère ces exceptions.

Toutes les exceptions non cochées étendent la classeRuntimeException.

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

4.1. NullPointerException

Si une application tente d'utilisernull là où elle a réellement besoin d'une instance d'objet, la méthode lèvera unNullPointerException.

Il existe différents scénarios où les utilisations illégales denull provoquentNullPointerException. Examinons certains d’entre eux.

Appeler 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érencenull, nous obtenons unNullPointerException: 

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.

Cependant, if a piece of code tries to access an illegal index of an array, the respective method throws an ArrayIndexOutOfBoundException.

Voyons quelques exemples qui lancentArrayIndexOutOfBoundException: 

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

La classeString en Java fournit les méthodes pour accéder à un caractère particulier de la chaîne ou pour découper un tableau de caractères parmi lesString. Lorsque nous utilisons ces méthodes, elle convertit en interne lesString dans un tableau de caractères.

De nouveau, il pourrait y avoir une utilisation illégale des index sur ce tableau. Dans de tels cas, ces méthodes de la classeString lèvent lesStringIndexOutOfBoundsException.

Cette exceptionindicates that the index is either greater than or equal to the size of the String. StringIndexOutOfBoundsException étendIndexOutOfBoundsException.

La méthodecharAt(index) de la classeString lève cette exception lorsque nous essayons d'accéder à un caractère à l'index égal à la longueur deString’s ou à un autre index illégal: 

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

Très souvent, une application se retrouve avec des données numériques dans unString. Afin d'interpréter ces données comme numériques, Java permet la conversion deString en types numériques. Les classes wrapper telles queInteger, Float, etc. contiennent des méthodes utilitaires à cet effet.

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

Prenons l'extrait de code suivant.

Ici, nous déclarons unString avec une donnée alphanumérique. De plus, nous essayons d'utiliser les méthodes de la classe wrapperInteger pour interpréter ces données comme numériques.

Par conséquent, cela se traduit parNumberFormatException: 

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. De plus,ArithmeticException s'applique uniquement aux types de donnéesint andlong.

Par exemple, si nous essayons de diviser un entier par zéro, nous obtenons unArithmeticException: 

int illegalOperation = 30/0; // Throws ArithmeticException

4.6. ClassCastException

Java autorise lestypecasting entre les objets afin de prendre en charge l'héritage et le polymorphisme. Nous pouvons soit monter un objet, soit le baisser.

Dans la conversion ascendante, nous lançons un objet dans son supertype. Et dans le downcasting, nous lançons un objet dans l’un de ses sous-types.

Cependant,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.

L'instance d'exécution est ce qui compte réellement dans la conversion de type. Considérez l'héritage suivant entreAnimal,Dog, and Lion: 

class Animal {}

class Dog extends Animal {}

class Lion extends Animal {}

De plus, dans la classe de pilote, nous convertissons la référenceAnimal contenant une instance deLion en unDog.

Cependant, lors de l'exécution, la JVM remarque que l'instanceLion n'est pas compatible avec le sous-type de la classeDog.

Cela donneClassCastException: 

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

4.7. IllegalArgumentException

Une méthode lance unIllegalArgumentException si nous l'appelons avec des arguments illégaux ou inappropriés.

Par exemple, la méthodesleep() de la classeThread attend un temps positif et nous passons un intervalle de temps négatif comme argument. Cela donneIllegalArgumentException: 

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

4.8. IllegalStateException

IllegalStateException signale qu'une méthode a été invoquée à un moment illégal ou inapproprié.

Chaque objet Java a un état (variables d'instance) et un comportement (méthodes). Ainsi,IllegalStateException signifie qu'il est illégal d'invoquer le comportement de cet objet avec les variables d'état actuelles.

Cependant, avec des variables d'état différentes, cela pourrait être légal.

Par exemple, nous utilisons un itérateur pour itérer une liste. Chaque fois que nous en initialisons un, il définit en interne sa variable d'étatlastRet à -1.

Dans ce contexte, le programme tente d'appeler la méthoderemove sur la liste: 

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

intListIterator.remove(); // IllegalStateException

En interne, la méthoderemove vérifie la variable d'étatlastRet et si elle est inférieure à 0, elle renvoieIllegalStateException.  Ici, la variable pointe toujours vers la valeur -1.

En conséquence, nous obtenons unIllegalStateException.

5. Conclusion

Dans cet article, nous avons d'abord discuté de ce que sont des exceptions. Unexception 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 Checked et les Exceptions non contrôlé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 articleover on GitHub.

Related