1. Détecter les exceptions spécifiques
Détectez toujours l’exception la plus spécifique en premier. Cela aide à identifier le problème exact et à le traiter de manière appropriée.

try {
    // Code that may throw an exception
} catch (FileNotFoundException e) {
    // Handle FileNotFoundException
} catch (IOException e) {
    // Handle other IOExceptions
}

2. Évitez les blocs de capture vides
Les blocs catch vides peuvent masquer les erreurs et rendre le débogage difficile. Enregistrez toujours l'exception ou prenez des mesures.

try {
    // Code that may throw an exception
} catch (IOException e) {
    e.printStackTrace(); // Log the exception
}

3. Utiliser le bloc Finalement pour le nettoyage
Le bloc final est utilisé pour exécuter du code important tel que la fermeture de ressources, qu'une exception soit levée ou non.

BufferedReader reader = null;
try {
    reader = new BufferedReader(new FileReader("file.txt"));
    // Read file
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (reader != null) {
        try {
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4. N'attrapez pas le jetable
Évitez d'attraper Throwable car il inclut des erreurs qui ne sont pas censées être détectées, telles que OutOfMemoryError.

try {
    // Code that may throw an exception
} catch (Exception e) {
    e.printStackTrace(); // Catch only exceptions
}

5. Consigner correctement les exceptions
Utilisez un framework de journalisation comme Log4j ou SLF4J pour consigner les exceptions au lieu d'utiliser System.out.println.

private static final Logger logger = LoggerFactory.getLogger(MyClass.class);

try {
    // Code that may throw an exception
} catch (IOException e) {
    logger.error("An error occurred", e);
}

6. Relancer les exceptions si nécessaire
Parfois, il est préférable de renvoyer l'exception après l'avoir enregistrée ou après avoir effectué une action.

try {
    // Code that may throw an exception
} catch (IOException e) {
    logger.error("An error occurred", e);
    throw e; // Rethrow the exception
}

7. Utiliser des blocs multi-catchs
Dans Java 7 et versions ultérieures, vous pouvez intercepter plusieurs exceptions dans un seul bloc catch.

try {
    // Code that may throw an exception
} catch (IOException | SQLException e) {
    e.printStackTrace(); // Handle both IOException and SQLException
}

8. Évitez d'abuser des exceptions pour le flux de contrôle
Les exceptions ne doivent pas être utilisées pour le flux de contrôle régulier. Ils sont destinés à des conditions exceptionnelles.

// Avoid this
try {
    int value = Integer.parseInt("abc");
} catch (NumberFormatException e) {
    // Handle exception
}

// Prefer this
if (isNumeric("abc")) {
    int value = Integer.parseInt("abc");
}