mouaïii (pour, mais avec reserve).
Comme la majorité: le principe est bon, la syntaxe est un peu à revoir.
En y réfléchissant, j'ai pas trouvé autre chose que le célebrissime virgule. Mais c'est pas très génial non plus
mouaïii (pour, mais avec reserve).
Comme la majorité: le principe est bon, la syntaxe est un peu à revoir.
En y réfléchissant, j'ai pas trouvé autre chose que le célebrissime virgule. Mais c'est pas très génial non plus
Je suis pour. Et sans vouloir lever une nouvelle polémique qui semble choquer beaucoup, je dois admettre que personnellement je trouve la notation « | » (façon opérateur logique) tout à fait explicite.
Je rajouterai contre le | qu'il est incohérent avec le reste de ce qui est fait en JAVA. C'est illogique d'utiliser le | pour les catch si on ne fait pas également:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5 class MaClasse implements Serializable & Clonable & Comparable { public void maFonction() throws IOException | NullPointerException{ ... } }
ca marche tres bien en python pourquoi pas en java
Bonjour.
Bah ... peut être que parceque Java est très différent de Python et ce sur tous les plans ?
Bref, ce genre de raisonnement n'est pas valable, sinon, on finirait par avoir une sorte de mélange hétérogène de trucs empreintés à d'autres langages et qui ne collent pas forcément dans la logique de Java.
Bonjour,
Le fait d'attraper en une seule ligne plusieurs erreurs me semble être une bonne idée.
Il est eventuellement faisable de faire hériter les erreurs d'une classe abstraite dans le but d'en attraper une seule lorsqu'il est succeptible d'arriver plusieurs erreurs, supposons :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5 public class abstract Erreur extends IOException {} public class ErreurType1 extends Erreur {} public class ErreurType2 extends Erreur {}
Bonjour
3 choses:
- C'est déjà le cas: Le type Throwable est le parent de toutes les exceptions, quel que'elles soient.
- T'as pas toujours le contrôle dessus: si tu travailles avec une API tièrce (tu le fais à 90% du temps ), tu peux pas leur imposer de lancer tel ou tel type d'exceptions.
- C'est pas très malin d'attraper un type d'esceptions plus général que ceux que tu attends.
même remarque que dans la proposition d'un switch sur String.
Je trouvé enuiyeux de faire plusieurs catch et ne pas catcher tous les exceptions dans une seule.
Pour le principe, mais effectivement la symtaxe pourrait etre améliorée, en particulier en utilisant l'ancetre des exceptions: cette information est a mon avis essentielle pour le compilateur, a moins de descendre tres bas par défaut (Throwable), mais je trouverai ça une très mauvaise pratique.
On peut bien faire un catch(Exception e), mais parfois c'est vraiment trop générique, un niveau intermédiaire entre catcher toutes les exceptions une à une et catcher Exception, ça peut être utile, donc oui.
Une fois, en écrivant plein de fois le même traitement pour des exceptions différentes (mais sans liens de parenté direct), je m'étais dit "ça serait vachement bien de faire ça"... Faudrait le proposer...
Jusqu'à ce que je me dise :
quel est le type apparent de e?
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5 try { ... } catch(ExceptionType1, ExceptionType2 e) { e.methode(); }
Throwable? Exception? La plus proche ancêtre commun?
Question à laquelle je n'ai pas trouvé de réponse satisfaisante...
Effectivement, ça mérite réflexion... Pas non plus encore trouvé de solution qui me plaise tellement...
L'idée qui me dérange le moins (à défaut de me satisfaire...), serait que si on veut catcher plusieurs exceptions à la foi, alors le type de l'exception n'est pas trop important, vu qu'on veut un seul traitement pour toutes.
Par exemple :
Dans le cas ci-desssus, le e.getMessage() retournerait les e.getMessage() concaténés de chaque exception catchée, ou un message d'erreur citant les exceptions catchées, ou quelque chose comme ça. Mais le traitement même de l'erreur ne devrait pas dépendre d'un type ou de l'autre, vu qu'on veut un seul catch pour les deux types.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5 try { ... } catch ({ExceptionA, ExceptionB} e) { logger.error(e.getMessage); }
Si on veut pouvoir déterminer le type de e, alors y'a qu'à faire un catch pour chaque type d'exception... et du coup on oublie cette proposition 7.
En fait ce n'est pas l'idée du tout. On ne peut pas et ne pourra pas catcher pas plusieurs exceptions en meme temps. Ce serait totalement incompatible avec la notion actuelle d'exception qui interromp le block d'execution.
Il n'y a donc pas de question a ce poser de concaténation ou autre traitement particulier.
La variable ne ne peux en effet etre du type ExceptionA ou ExceptionB, il faudra obligatoirement un ancêtre commun, ça pourrait être Throwable mais c'est réducteur. Je pense que le plus judicieux serait de spécifier cet ancêtre(cf ma proposition).
C'est personnel, mais en fait je trouve très bien la situation actuelle. Je ne vois pas tellement de bonne solution pour catcher plusieurs exceptions en même temps. Si on a besoin de le faire, c'est sûrement que dans le try {...}, il y a une bonne quantité de code. Et que donc la gestion des exceptions pourrait être améliorée... On peut même implémenter ses propres exceptions pour ça.
Je suis plutôt pour, mais je crois je la vrai solution au merdier serait de changer la hierarchie des class d'Exception.
Throwable devrait être unchecked.
Error extends throwable devrait contenir toutes les erreur découlant d'erreurs de programmation (NullPointerException --> NullPointerErrorr, etc...) et non pas de circonstance non controllées par le programmeur.
Exception devrait devenir unchecked (comme l'est RuntimeException).
RuntimeException devrait être supprimée et une nouvelle class CheckedException devrait être créée et utilisée avec modération.
Ceci enleverait 90% du code de traitement des erreur sans en réduire la fonctionnalité (qui peut me dire la dernière fois qu'il a codé autre chose qu'un rethrow ou un log de l'erreur).
Throwable ne peut pas être unchecked, car cela impliquerait que toutes les classes filles serait unchecked, et donc qu'il n'y aurait plus de checked-exception...
Ca c'est ce que font les RuntimeException ! Les Errors concernent justement toutes les circonstances non controllées par le développeur...
Même remarque que pour Throwable : cela reviendrait à dire que toutes les classes filles sont unchecked...
Je ne vois pas en quoi cela enlèverait 90% des codes de traitements...
Par contre cela casserait toute compatibilité à cause de la réorganisation de l'héritage des exceptions...
a++
Je suis totalement pour, il arrive qu'on ets plusieurs chose à catch... Mais le "|" m'as un peu choquer au début ^^ peros je préférerais un "," enfin bref...
Pour avec la virgule et déclaration de classe explicite.
Développeur Java SE, Java EE (EJB3)
IDE : Netbeans 6.5 / Serveur d'application : Glassfish v2.1 / OS : Ubuntu 8.10 Intrepid Ibex et CentOS 5
Historique : GWBasic, Turbo Pascal (beaucoup), Visual Basic, C (un peu), C++ (beaucoup), Assembleur (6800 et x86 / un peu), Java, Smalltalk (un peu), Lisp (un peu), Prolog (un peu), PHP, Ruby (un peu), et retour à Java (beaucoup).
Pas de questions techniques par MP s'il vous plait !
Vous avez un bloqueur de publicités installé.
Le Club Developpez.com n'affiche que des publicités IT, discrètes et non intrusives.
Afin que nous puissions continuer à vous fournir gratuitement du contenu de qualité, merci de nous soutenir en désactivant votre bloqueur de publicités sur Developpez.com.
Partager