Est-ce une bonne pratique d'utiliser la suppression des avertissements dans votre code?

J'utilise @SuppressWarnings("unchecked")et @SuppressWarnings("null")surtout les méthodes ci-dessus pour laisser le code se compiler sans aucun avertissement mais j'ai mes doutes. Trouvé cette question Stackoverflow . Jon Skeet y a écrit une réponse que je trouve intrigante.

Selon lui,

Parfois, les génériques Java ne vous permettent tout simplement pas de faire ce que vous voulez, et vous devez dire au compilateur que ce que vous faites sera vraiment légal au moment de l'exécution.

Mais que se passe-t-il s'il y a une chance qu'une exception soit levée? La suppression des avertissements n'est-elle pas alors une mauvaise idée? Ne devrais-je pas être conscient des endroits où des problèmes pourraient surgir?

De plus, que se passe-t-il si quelqu'un d'autre modifie mon code plus tard et ajoute des fonctionnalités discutables sans supprimer SuppressWarnings? Comment éviter cela et / ou existe-t-il une autre alternative à cela?

Dois-je utiliser @SuppressWarnings("unchecked")et @SuppressWarnings("null")?

Mise à jour # 1

En ce qui concerne les conversions de type non contrôlées, selon cette réponse (soulignée par @gnat dans les commentaires ci-dessous), la suppression de ces avertissements est nécessaire.

De nombreuses bibliothèques Java indispensables n'ont jamais été mises à jour pour éliminer le besoin de transtypages non sécurisés. La suppression de ces avertissements est nécessaire pour que d'autres avertissements plus importants soient remarqués et corrigés.

En cas de suppression d'autres avertissements, toujours dans une zone grise.

Mise à jour # 2

Selon Oracle Docs (également mentionné par certaines réponses ci-dessous):

Pour des raisons de style, les programmeurs doivent toujours utiliser cette annotation sur l'élément le plus profondément imbriqué où elle est efficace. Si vous souhaitez supprimer un avertissement dans une méthode particulière, vous devez annoter cette méthode plutôt que sa classe.

Pour moi, le but de supprimer les avertissements est de maintenir un «bilan de santé propre» pour votre projet. Si vous savez que l'intégralité de votre base de code se compile correctement, il est immédiatement évident lorsque quelqu'un fait quelque chose de mal qui fait apparaître le premier avertissement dans la liste des problèmes. Vous pouvez ensuite corriger l'erreur ou la supprimer si vous pouvez prouver qu'elle est fausse.

Mais si vous avez 21 avertissements là-dedans pour commencer, il est beaucoup plus probable que vous oubliez le 22 quand quelqu'un le provoque, et vous ne vérifiez pas qu'il est inoffensif. Cela signifie que des problèmes peuvent se glisser dans votre base de code et que vous ne le remarquerez jamais.

Les avertissements sont des informations utiles. Assurez-vous de tenir compte de ceux qui disent la vérité et de filtrer ceux qui ne le font pas. Ne laissez pas les gens confondre les deux types afin de perdre votre système d'alerte précoce.

Éditer

Je devrais probablement préciser que supprimer un avertissement qui a du mérite est une chose stupide à faire. Un bilan de santé propre que vous avez obtenu en trichant ne vaut évidemment rien. Étant donné le choix, vous devriez toujours résoudre le problème que le compilateur a remarqué plutôt que de simplement fermer les yeux. Cependant, il y a des domaines dans lesquels le compilateur ne peut pas être sûr que quelque chose posera problème ou non (les génériques de Java en font partie), et là le meilleur choix est d'examiner chaque instance de ce type, puis de supprimer l'avertissement à cet endroit spécifique plutôt que de désactiver complètement cette classe d'avertissement et de manquer potentiellement une véritable.

La suppression des avertissements doit être effectuée avec une extrême prudence.

Un avertissement signifie: le compilateur a trouvé quelque chose qui semble douteux. Cela ne signifie pas qu'il est douteux, il ressemble juste au compilateur. Parfois, vous avez du code qui est parfaitement bien et donne un avertissement. Parfois, vous le corrigez en modifiant légèrement votre code. Parfois, le compilateur a une fonctionnalité spécialement conçue à cet effet. Par exemple où

if (x = someFunction ()) { ... }

donne un avertissement mais

if ((x = someFunction ())) { ... }

non. Dans le premier cas, un avertissement supposant que vous vouliez dire == et non =. Dans le second cas, aucun avertissement car les parenthèses supplémentaires indiquent au compilateur "Je sais ce que je fais". Il vaudrait mieux, bien sûr,

if ((x = someFunction ()) != 0) { ... }

ou en utilisant deux lignes.

Et parfois, très rarement, il y a des cas où votre code est correct mais vous ne parvenez pas à l'écrire d'une manière acceptée sans avertissement. Dans ce cas très, très rare, vous désactivez un avertissement pour cette déclaration et l'activez immédiatement après. C'est un dernier recours. Et vous ne désactivez que cet avertissement spécifique, pas d'autres.

Cependant, certaines personnes désactivent simplement les avertissements pour se débarrasser des avertissements, car ils sont trop paresseux pour découvrir et fixer d'abord la raison d'un avertissement légitime. Ou bien ils n'essaient même pas d'écrire du code sans avertissement. C'est une chose extrêmement malsaine à faire.

La suppression de l'avertissement pour une méthode entière est suspecte. Mieux vaut supprimer les avertissements pour la ligne spécifique, avec un commentaire . par exemple

@SuppressWarnings("unchecked") Foo foo = (Foo)object; // Using old library requires this cast