Le langage de programmation Java fournit un mécanisme permettant de gérer les exceptions lancées par le programme.

Lorsqu'une exception se produit, le traitement normal du programme s'interrompt et l'environnement d'exécution tente de trouver le gestionnaire d'exception chargé de gérer le type d'erreur en cours.

Le gestionnaire d'exception peut tenter de récupérer l'erreur si cela est possible, sinon il essayera de provoquer une sortie correcte du programme.

try{
  // Instructions...
}
catch (type_exception1 nom){
  // Instructions de traitement d'exception
}
...
catch (type_exceptionN nom){
  // Instructions de traitement d'exception
}
finally{
  // Instructions de fin...
}

L'instruction try contient un bloc d'instructions à l'intérieur duquel une exception pourrait se produire.

L'instruction catch doit être associée à try et contient un bloc d'instructions susceptible de gérer un type d'exception particulier.

L'instruction finally facultative, doit être associée à try et placée après catch. Elle contient un bloc d'instructions qui est exécuté dans tous les cas de figure.

Il est possible d'utiliser plusieurs instructions catch afin de capturer des exceptions de types différents.

Cette succession de blocs catch doit correspondre à un ordre précis afin de correspondre à la hiérarchie inverse des classes d'exception.

Ainsi, les types d'exception risquant de se produire dans les sous-classes inférieures d'une hiérarchie devront être traités en premier, suivi de ceux des classes supérieures.

Si une exception se produit dans le bloc try, alors la machine virtuelle Java recherchera le bloc catch le plus approprié à l'exception en cours.

try {
  // Bloc d'instructions...
}
catch (FileNotFoundException e) {
  // Gestion des exceptions de fichier non trouvé
}
catch (IOException e) {
  // Gestion des exceptions d'entrée/sortie
}
catch (Exception e) {
  // Gestion des exceptions
}

Par exemple, si une exception du type FileNotFoundException se produit dans le bloc try, le bloc catch (FileNotFoundException e) intercepterait et gérerait l'exception en cours.
Si une exception du type EOFException se produit, alors ce serait au tour du bloc catch (IOException e) de traiter cette exception puisqu'elle est provient d'une sous-classe de IOException.
Enfin, si une exception du type BadLocationException se produit, alors le dernier bloc catch prendrait en compte cette exception car celle-ci descend de la classe Exception.

Les instructions try... catch peuvent être imbriquées les unes dans les autres.

try {
  // Bloc try 1
  ...
  try {
  // Bloc try 2
  ...
  }
  catch (TypeException e) {
  ...
  }
  ...
}
catch (TypeException e) {
  ...
}

Dans ce cas, si une exception est lancée dans le second bloc try terminant de fait son exécution, son bloc catch est vérifié pour une éventuelle interception. S'il n'est pas en mesure de gérer l'exception, alors cette dernière est propagée dans le premier bloc try qui ensuite transmet l'exception à son bloc catch.