FAQ Langage JavaConsultez toutes les FAQ

1
2
MonException monException = new MonException("Il y a eu une erreur"); 
throw monException;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/** 
 * Ma méthode à moi. 
 * @param parametre1 Le paramètre de la méthode. 
 * @throws NullPointerException Si {@code parametre1} est {@code null}. 
 * @throws MonException En cas d'erreur. 
 */ 
public void maMethode(String parametre1) throws NullPointerException, MonException  { 
    Objects.requireNonNull(parametre1); // Peut signaler une NullPointerException 
    [...] 
    if (testEchoue) {  // Si le test échoue, on signale une MonException.   
        MonException monException = new MonException("Il y a eu une erreur"); 
        throw monException; 
    } 
}

1
2
3
4
5
6
7
8
try { 
    // Instructions précédentes. 
    maMethode("toto");// Méthode pouvant signaler une MonException. 
    // Instructions suivantes. 
} catch (MonException e) {    
    // Traitement à effectuer sur l'exception. 
    [...] 
}

1
2
3
4
5
6
7
8
9
try { 
    // Instructions précédentes. 
    maMethode("toto");// Méthode pouvant générer une MonException. 
    // Instructions suivantes. 
} catch (MonException e) { 
    // Traitement à effectuer sur l'exception. 
    [...] 
    throw e; 
}

1
2
3
4
5
6
7
8
9
10
11
try { 
    // Action signalant une exception. 
} catch (FileNotFoundException e1) { 
    // Traitement spécifique pour l'absence de fichier. 
} catch (IOException e2) { 
    // Traitement général pour les erreurs d’entrée/sortie. 
} catch (NullPointerException e3) { 
    // Traitement pour un problème de référence nulle. 
} catch (Throwable t) { 
    // Traitement générique pour des exceptions de type runtime non planifiées. 
}

1
2
3
4
5
6
7
8
9
try { 
    // Action signalant une exception. 
} catch (FileNotFoundException e1) { 
    // Traitement. 
} catch (ZipException e2) { 
    // Traitement identique au précédent. 
} catch (ClosedChannelException e3) { 
    // Traitement identique au précédent. 
}

1
2
3
4
5
try { 
    // Action signalant une exception. 
} catch (IOException e) { 
    // Traitement. 
}

1
2
3
4
5
6
7
try { 
    // Action signalant une exception. 
} catch (IOException e1) { 
    // Traitement. 
} catch (SQLException e2) { 
    // Traitement. 
}

1
2
3
4
5
try { 
    // Action signalant une exception. 
} catch (IOException | SQLException ex) { 
    // Traitement. 
}

1
2
3
4
5
6
7
8
9
try { 
    maMethode("toto"); // Méthode pouvant signaler une MonException.  
} catch (MonException e) { 
    // Traitement à effectuer sur l'exception. 
    [...] 
} finally { 
    // Le contenu de ce bloc est tout le temps exécuté que l'exception soit signalée ou pas. 
    [...] 
}

1
2
3
4
5
6
7
8
public void uneAutreMethode() throws MonException { 
    try { 
         maMethode("toto"); // Méthode pouvant signaler une MonException. 
    } finally { 
        // Le contenu de ce bloc est tout le temps exécuté que l'exception soit signalée ou pas. 
        [...] 
    } 
}

1
2
3
4
5
6
7
8
9
InputStream input = null; 
try { 
    input = new FileInputStrean(fichier); // Peut signaler une IOException.    
    [...]    // Opérations qui peuvent signaler une IOException.    
} finally { 
    if (input!= null) { 
        input.close(); // Peut signaler une IOException. 
    } 
}

1
2
3
try (InputStream input = new FileInputStrean(fichier)) { // Peut signaler une IOException. 
    [...]  // Opérations qui peuvent signaler une IOException.    
}

1
2
3
try (InputStream input = new FileInputStrean(fichier) ;  InputStreamReader reader = new InputStreamReader(input)) { // Peuvent signaler une IOException. 
    [...]  // Opérations qui peuvent générer une IOException.    
}

1
2
3
4
5
6
try { 
    // Lecture du contenu du fichier. 
} catch (NumberFormatException e1) { 
    IOException e2 = new IOException("Erreur de lecture du fichier", e1); 
    throw e2; 
}

1
2
3
4
5
6
7
try { 
    // Lecture du contenu du fichier. 
} catch (NumberFormatException e1) { 
    IOException e2 = new IOException("Erreur de lecture du fichier"); 
    e2.initCause(e1); 
    throw e2; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
List<Throwable> suppressed = new LinkedList<>; 
// Faire une ou plusieurs actions susceptibles de signaler des exceptions non critiques. 
// Comme ces exceptions ne sont pas critiques, elles n'interrompent pas le traitement, mais elles doivent être conservées. 
try { 
    [...] 
} catch (UneExceptionNonCritique erreur) { 
    suppressed.add(erreur); 
} 
// Fin du traitement. 
// Si des exceptions ont été supprimées, on génère une exception les contenant. 
if (!suppressed.isEmpty()) { 
   ExceptionMajeure ex = new ExceptionMajeure("Il y a eu des erreurs durant le traitement !"); 
   for (Throwable t : suppressed) { 
       ex.addSuppressed(t); 
   } 
   throw ex; 
}

1
2
String unsafeTypeDirName = project.getApplicationType().getTypeDirName(); 
System.out.println(unsafeTypeDirName);

1
2
3
4
5
6
7
8
9
10
// Sûr, mais pas très élégant, et un oubli est vite arrivé 
if (project != null) { 
    ApplicationType applicationType = project.getApplicationType(); 
    if (applicationType != null) { 
        String typeDirName = applicationType.getTypeDirName(); 
        if (typeDirName != null) { 
            System.out.println(typeDirName); 
        } 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Supposons que c’est ce que le modèle retournera dans le futur ; en attendant... 
Optional<Project> optionalProject = Optional.ofNullable(project); 
  
// Sûr, mais toujours peu séduisant et sujet à omissions. 
if (optionalProject.isPresent()) { 
    ApplicationType applicationType = optionalProject.get().getApplicationType(); 
    Optional<ApplicationType> optionalApplicationType = Optional.ofNullable(applicationType); 
    if (optionalApplicationType.isPresent()) { 
        String typeDirName = optionalApplicationType.get().getTypeDirName(); 
        Optional<String> optionalTypeDirName = Optional.ofNullable(typeDirName); 
        if (optionalTypeDirName.isPresent()) { 
            System.out.println(optionalTypeDirName); 
        } 
    } 
}

1
2
3
4
5
// Sûr, plus élégant. 
optionalProject 
    .map(project -> project.getApplicationType()) 
    .map(applicationType -> applicationType.getTypeDirName()) 
    .ifPresent(typeDirName -> System.out.println(typeDirName));

1
2
3
4
5
// Sûr, plus gracieux. 
optionalProject 
    .map(Project::getApplicationType) 
    .map(ApplicationType::getTypeDirName) 
    .ifPresent(System.out::println);