FAQ Langage JavaConsultez toutes les FAQ

Ce message indique que vous devez capturer et traiter une exception de type Checked exception dans le corps de votre méthode. En effet, le compilateur rend obligatoire le traitement de ce genre d'erreurs.

1
2
3
4
5
6
7
8
9
public void maMethode() { 
    try { 
        // Code qui peut générer une checked exception de type MonException. 
        [...] 
    } catch (MonException ex) { 
        // Traitement de l'exception. 
        [...] 
    } 
}

1
2
3
4
public void maMethode() throws MonException { 
    // Code qui peut lancer une checked exception de type MonException. 
    [...] 
}

L'exception java.lang.NullPointer est une Runtime exception qui est générée lorsque l'application essaye d'utiliser une instance d'un objet, mais que celle-ci est à la valeur null. Cela inclut :

• l'appel d'une méthode sur un objet dont la référence a une valeur null ;
• la lecture ou la modification d'un champ sur un objet dont la référence a une valeur null ;
• demander la longueur d'un tableau dont la référence a une valeur null ;
• la lecture ou la modification d'une case d'un tableau dont la référence a une valeur null ;
• générer une exception dont la valeur est null.
  

L'exception java.lang.IndexOutOfBoundsException est une Runtime exception qui est générée lorsque l'on essaie d'accéder à une case d'un tableau (ou d'une collection) qui n'existe pas.

Il faut avant tout vérifier la valeur indiquée dans le message de l'exception pour savoir si on ne tente pas d'accéder à une case inexistante.

1
2
3
4
5
int [] monTab=new int[20]; // creation d'un tableau de taille 20 
for(int i=0;i<20;i++) { 
   tab[i]=i; // on le remplit 
} 
System.out.println(tab[20]); // on accède à la 21e case en voulant accéder à l'indice 20...

L'exception java.lang.ClassNotFoundException est une Checked exception qui peut être générée principalement de trois manières :

• la méthode forName() de la classe java.lang.Class ;
• la méthode findSystemClass() de la classe java.lang.ClassLoader ;
• la méthode loadClass() de la classe java.lang.ClassLoader.
  

• soit que votre CLASSPATH est mal configuré ;
• soit que les droits du fichier JAR ou du fichier CLASS ne permettent pas la lecture de celui-ci pour l'utilisateur courant.
  

L'exception java.lang.SecurityException est une Runtime exception que le gestionnaire de sécurité de la JVM peut générer quand vous tentez d’accéder à des ressources protégées.

Cela peut être le cas pour les Applets, par exemple. Celles-ci doivent être signées pour pouvoir accéder aux ressources de la machine cliente, (système de fichiers, classe Robot, etc.). Vous pouvez aussi tenter d'éditer le fichier java.policy de la JVM pour régler ces droits d'accès.

L'erreur java.lang.OutOfMemoryError est générée lorsque la JVM ne peut plus allouer de mémoire pour un nouvel objet. Cela survient lorsque le ramasse-miettes ne peut plus en libérer.

Une possibilité pour contourner ce problème est d'allouer plus de mémoire au lancement de la JVM avec l'option -Xmsn. Vous pouvez aussi fixer la taille maximale de la mémoire avec l'option -Xmxn. Ici, n indique la mémoire initiale disponible. Les valeurs par défaut sont respectivement de 2 Mo et 64 Mo.

Voici un exemple de notation :

1
2
3
4
5
6
java -Xms6291456 
# 6291456 bytes 
java -Xms6144k 
# 6144 kilo-octets 
java -Xms6m 
# 6 méga-octets

Avant le JDK 7
Dans une application graphique, certaines exceptions se déclenchent depuis le thread dédié à l'affichage. Il n'est pas possible d'intercepter ces exceptions avec un bloc try/catch classique.

Il est cependant possible d'enregistrer une classe qui sera chargée de gérer ces erreurs. Pour ce faire la propriété système sun.awt.exception.handler doit contenir le nom complet d'une classe ayant une méthode handle(Throwable erreur).

Cela peut être fait en passant l'option -Dsun.awt.exception.handler=<nom de la classe> à la machine virtuelle ou par le biais de la méthode setProperty() de la classe java.lang.System au lancement du programme.

À chaque exception non interceptée, une nouvelle instance de cette classe est créée. Vous devez donc fournir un constructeur vide. Ensuite, la méthode handle() est invoquée.

Cette manière de faire ne fonctionne plus à partir du JDK 7.

JDK 5
À partir du JDK 5, on peut utiliser l'interface java.lang.Thread.UncaughtExceptionHandler. Cette interface est utilisable par deux méthodes de la classe java.lang.Thread :

• setDefaultUncaughtExceptionHandler() - cette méthode statique permet de positionner un gestionnaire d'erreur par défaut commun à tous les threads ;
• setUncaughtExceptionHandler() - cette méthode permet de positionner un gestionnaire d'erreur thread par thread.
  

Le compilateur refusera de compiler du code contenant un multi-catch si ce bloc contient un type parent d'une des autres exceptions capturées par le catch.

Par exemple :

1
2
3
4
5
try { 
    [...] 
} catch (ArrayIndexOutOfBoundsException | IndexOutOfBoundsException ex) {             
    [...] 
}

1
2
3
4
5
try { 
    [...] 
} catch (IndexOutOfBoundsException ex) {             
    [...] 
}

1
2
3
4
5
try { 
    [...] 
} catch (NumberFormatException | FileNotFoundException | SocketException | IOException ex) {             
    [...] 
}

1
2
3
4
5
try { 
    [...] 
} catch (NumberFormatException | IOException ex) {             
    [...] 
}

Avant le JDK 1.4

1
2
3
4
Throwable t = new Throwable();  
StringWriter sw = new StringWriter();  
t.printStackTrace(new PrintWriter(sw, true));  
String stackTrace = sw.toString();

1
2
Throwable t = new Throwable();  
StackTraceElement traces[] = t.getStackTrace();