Comment gérer les exceptions vérifiées qui ne peuvent jamais être levées

Exemple:

foobar = new InputStreamReader(p.getInputStream(), "ISO-8859-1");

Comme l'encodage est codé en dur et correct, le constructeur ne lève jamais l'exception UnsupportedEncodingException déclarée dans la spécification (à moins que l'implémentation java soit interrompue, auquel cas je suis perdu de toute façon). Quoi qu'il en soit, Java m'oblige de toute façon à traiter cette exception.

Actuellement, ça ressemble à ça

try {
    foobar = new InputStreamReader(p.getInputStream(), "ISO-8859-1");
}
catch(UnsupportedEncodingException e) { /* won't ever happen */ }

Des idées pour l'améliorer?

Mon habitude est, par sécurité, de mettre un point assertdans le bloc. Quelqu'un pourrait changer le contenu du trybloc plus tard, et vous voulez savoir si le code échoue, n'est-ce pas?

Si on me donnait un centime à chaque fois que je voyais un journal / une erreur, "cela ne devrait jamais arriver", j'aurais ... eh bien, deux centimes. Mais reste...

Les blocs d'arrêt vides font vibrer mes sens et les plus bons outils d'analyse de code se plaignent. J'éviterais à tout prix de les laisser vides. Bien sûr, vous savez maintenant que l'erreur ne peut jamais se produire, mais dans un an, quelqu'un effectuera une recherche-remplacement global de "ISO-8859-1" et vous risquez d'avoir un bogue extrêmement difficile à trouver.

La assert falsesuggestion est bonne, mais comme les assertions peuvent être désactivées au moment de l'exécution, elles ne constituent aucune garantie. Je voudrais utiliser un RuntimeExceptionlieu. Ceux-ci n'auront pas à être attrapés en appelant des classes et s'ils se produisent, vous aurez une trace de pile pour donner des informations complètes.

Je l'ai toujours fait comme ça:

try {
    foobar = new InputStreamReader(p.getInputStream(), "ISO-8859-1");
} catch(UnsupportedEncodingException e) {
    throw new AssertionError(e);
}

Peut-être un peu prolixe (Java est ...), mais au moins vous obtiendrez une erreur d'assertion lorsque l'impossible se produira.

Si l'implémentation Java est interrompue, vous souhaiterez obtenir le meilleur message d'erreur possible, le plus rapidement possible, au lieu de simplement ignorer l'impossible. Et même si l'implémentation Java n'est pas rompue, quelqu'un aurait pu changer votre code en "UTF8"(oups - devrait-il en être ainsi "UTF-8"?).

Cela aurait dû être une exception d'exécution en premier lieu. JDK est plein de ce genre de mauvais choix.

Si vous êtes le seul développeur à avoir accès à ce code, je dirais que c'est correct, mais si vous ne l'êtes pas, je le traiterais comme une possibilité réelle ou du moins changerais le commentaire "ne se produira jamais". quelque chose de plus utile.

La partie de ces exceptions qui m'agace le plus est que cela nuit à la couverture de mon code.

Lorsque la couverture devient compulsive, je vais essayer de comprendre que "ne peut jamais arriver" (... ou seulement si j'utilise une JVM mutante qui avait oublié d'inclure "US-ASCII") dans une classe et une méthode qui encapsule cette tentative / intercepte et remplace l’exception vérifiée de l’une des manières mentionnées ici (généralement, en lançant une exception non contrôlée avec un message discret).

Ensuite, ma couverture de code prend un coup dans la classe utilitaire, mais pas dans toutes les références à cette opération dispersées autour de mon code.

Parfois, je prends le temps de faire comme dans une classe où la sémantique est cohérente. Mais comme il est assez évident pour mes coéquipiers de savoir ce qui se passe, je tiens généralement à le garder aussi simple que possible et à ne pas trop m'inquiéter du meilleur design possible.

Cependant, comme mentionné dans un commentaire, Guava et d'autres bibliothèques ont des moyens d'atténuer cette douleur - mais c'est fondamentalement la même stratégie. Déplacez le désagrément en dehors de la scène afin que votre code principal ne soit pas touché par la couverture.