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);