Plusieurs blocs catch "ChildException" versus un bloc catch "Exception"

Question

Quoi de mieux entre plusieurs blocs catch ChildException et un bloc catch Exception? Par mieux, je veux dire de bonnes pratiques.

À titre d'illustration:

public static void main(String[] args) { 
    System.out.println(Main.isNonsense1(null)); // false <- bad 
    System.out.println(Main.isNonsense2(null)); // NullPointerException <- good 
} 

// More readable, less precise 
public static boolean isNonsense1(String className) { 
    try { 
     Class.forName(className); 
     String.class.getConstructor(String.class); 
     className.getBytes("UTF-8"); 
     MessageDigest.getInstance("SHA-1").wait(); 
     return true; 
    } catch (Exception e) { 
     return false; 
    } 
} 

// Less readable, more precise 
public static boolean isNonsense2(String className) { 
    try { 
     Class.forName(className); 
     String.class.getConstructor(String.class); 
     className.getBytes("UTF-8"); 
     MessageDigest.getInstance("SHA-1").wait(); 
     return true; 
    } catch (ClassNotFoundException e) { 
     return false; 
    } catch (NoSuchMethodException e) { 
     return false; 
    } catch (SecurityException e) { 
     return false; 
    } catch (UnsupportedEncodingException e) { 
     return false; 
    } catch (NoSuchAlgorithmException e) { 
     return false; 
    } catch (InterruptedException e) { 
     return false; 
    } 
} 

Answer 1

Ceci est lié à cette question: Catch multiple exceptions at once?

La réponse est bonne. La clé est que si vous attrapez Exception alors vous devez gérer chacun des cas que vous connaissez et throw tout le reste. C'est-à-dire, simplement attraper Exception dans votre exemple et retourner false serait pas être une bonne idée. Vous pouvez attraper par inadvertance une exception que vous ne vouliez pas.

En utilisant votre exemple, voici mon code suggéré:

public static boolean isNonsense2(String className) { 
    try { 
     Class.forName(className); 
     String.class.getConstructor(String.class); 
     className.getBytes("UTF-8"); 
     MessageDigest.getInstance("SHA-1").wait(); 
     return true; 
    } catch (Exception e) { 
     if (e instanceof ClassNotFoundException 
       || e instanceof NoSuchMethodException 
       || e instanceof SecurityException 
       || e instanceof UnsupportedEncodingException 
       || e instanceof NoSuchAlgorithmException 
       || e instanceof InterruptedException) { 
      return false; 
     } else { 
      throw e; 
     } 
    } 
} 

Answer 2

Je pense qu'il n'y a pas de réponse claire complète. Dans votre cas, je coder comme ceci:

public static boolean isNonsense1(String className) { 
    if(slassname==null) throw new IllegalArgumentException("className must not be null"); 
    try { 
     Class.forName(className); 
     String.class.getConstructor(String.class); 
     className.getBytes("UTF-8"); 
     MessageDigest.getInstance("SHA-1").wait(); 
     return true; 
    } catch (ClassNotFoundException e) { 
     throw new IllegalArgumentException("provided class " + className + " not found"); 
    } catch (Exception e) { 
     return false; 
    } 
} 

Pour mon goût, jetant un NullPointerException est toujours mauvais, c'est pourquoi je jette le IllegalArgumentException

Answer 3

Si vous n'êtes pas intéressé à gérer l'exception (que vous devez selon les meilleures pratiques) ne vous embêtez pas avec les prises explicites. Le but de pouvoir gérer des exceptions spécifiques est de vous permettre de les gérer correctement.