Évidemment, l'une des plus grandes banales de la programmation Java est NULLS et NULL-POINTER Exception. Quels modèles de conception sont là qui n'ajoutent pas trop de votre code, mais réduisez le problème des exceptions de sable NULL-POINTER?
8 Réponses :
modèle d'objet null . Regardez en option classe de bibliothèque Google-Guava .
Leur wiki a un sur utiliser et éviter les nulls. < / p>
Je savais que Google-Guava avait beaucoup d'excellents friandises. Je ne savais pas que cela aborda ce problème.
Comment Null Object Motif peut-il réduire le problème des exceptions de sable NULL-POINTER ?
@Umnyobe: Si vous avez un objet au lieu de NULL, vous ne pouvez pas obtenir une nullpointerException.
Oui, mais si une situation extraordinaire se produit, pourquoi le programme devrait-il se comporter normalement?
@Joe: J'espère que vous ne vous préparez pas pour un monde de blessures dans la ligne. Une application qui contourne silencieusement les états d'erreur est beaucoup plus difficile à dépanner que celui qui crie et frappe.
@PAP Vous avez déjà fait votre point d'ailleurs. Si vous lisez dans cette solution, ce n'est pas celui qui se prête à ignorer silencieusement les nuls, juste pour mieux les manier.
Il suffit d'utiliser pour ne pas renvoyer des objets nuls sur vos méthodes. Aussi (type de) appelé modèle null-objet .
Ce n'est pas le modèle NULL-Object. Il y a une différence entre une chaîne vide et null. Le code invoquant (vous avez fait que cette après-vente publique) pourrait très raisonnablement vouloir prendre des décisions sur la base de savoir si ce qui était retourné était nul ou vide.
@Georgemauer, il pourrait très raisonnablement utiliser le résultat directement sur l'interface - auquel cas, c'est mieux montrer "null" ou rien?
@Marcelo - Votre mise à jour est plus proche du modèle NULL-Object. (Vraisemblablement) MyObject va être affiché dans l'interface en appelant tostring - Vous devez retourner myObject (null) et avoir simplement tostring () Renvoyez la chaîne vide dans ce cas particulier. De cette façon, invoquer le code peut toujours vérifier si le résultat était NULL (à l'aide d'un isnull () méthode peut-être) mais n'obtiendra pas des exceptions nulles. Voir la catégorie nullable <> en C # comme exemple solide.
Pourquoi voulez-vous éviter une exception de pointeur NULL? Obtenir EDIT:
Je pense que le meilleur moyen de réduire le retour NULL sera d'accroître l'utilisation des exceptions. Pensez à une liste renvoyant un objet NULL lorsque vous essayez d'accéder à l'élément à l'index -1, vous utiliserez des choses comme
qui est encore pire. Je crois qu'il vaut mieux soulever une exception lorsque les arguments sont inattendus ou incompatibles. NULL Lorsque vous attendez quelque chose d'autre, c'est l'une des premières indications Quelque chose ne va pas lorsque vous écrivez le code. Des choses comme Null Object motif doivent être utilisées lorsque vous êtes sûr qu'il est adéquat. L'un des plus grands inconvénients du modèle de conception est leur abus \ mauvaise utilisation.
si (list.get (-1) .equals (nullobject))
Des exceptions plus vérifiées sont préférables aux pointeurs nuls. Je n'aime pas les pointeurs nuls parce qu'ils indiquent que quelque chose ne va pas, mais ils font au moment de l'exécution. Quelque chose comme Null Object Motif est meilleur, car votre code suive l'erreur et peut fournir un antidote logique au problème.
Je suppose que c'est une question de goût, mais je dirais que les plus grandes banales de langues comme SmallTalk / Objective-C sont qu'ils n'ont pas nulle et qu'il n'y a pas de nullpointerexceptions. Je ne suis pas un fan de "Null Object modèle", je déteste en fait la passion que je trouve que cela fait dépannage et trouver des bugs tellement plus difficiles sans aucun avantage réel. Comme a été mentionné dans ce fil, NPE est vraiment puissant et un bon moyen d'attraper des erreurs syntaxiques ou un mauvais codage tôt et null a une signification (souvent mal) et ne doit pas être traité comme un autre état générique.
si (obj! = null) est assez simple. Si votre application commence à générer des NPE au moment de l'exécution, vous avez fait quelque chose de mal et vous devez le réparer. N'essayez pas de cacher l'exception, corrigez tout ce que c'est que cela provoque l'exception.
Null Pointer Exception est une exception décochée. Donc, le problème est que vous ne connaîtrez pas le problème avant d'exécuter du temps. Il est bien meilleur que votre code est écrit à l'adresse sans valeur pour quelque chose en premier lieu.
Bien sûr. C'est pourquoi vous vérifiez pour NULL-NESS. Ce que je trouve effrayant, c'est quand une valeur peut être nulle sans causer une réaction claire et appropriée (comme une NPE). L'ensemble "NULL est également une idée" d'un objet dans SmallTalk / Obj-C, je trouve simplement épouvantable. NULL n'est pas une valeur, c'est null.
Mais qu'en est-il d'un objet nul qui encapsule qu'il existe une erreur et même lance des exceptions vérifiées lorsqu'elle est utilisée après sa définition. Le problème avec la vérification de la nullité est que nous sommes humains et que nous puissions oublier de le faire. Null brise essentiellement le modèle d'objet Java. Si vous ne sentez pas que vous avez besoin d'une langue qui vous tient la main et vous rappelle de faire des choses, vous seriez plus productif dans une langue qui a plus faible de dactylographie que Java.
Il existe certaines annotations utiles conçues pour les objectifs de Thiese par Intellyj: @NULLABLE et
Détection de la NPE probable
maybeNullVar.equals("something definetly not null")
Ces méthodes (voir aussi Apache Commons-Lang) peuvent réduire le fardeau des chèques nuls dans les cas de traitement des chaînes en les encapsulant dans des méthodes qui conservent une signification sémantique du code:
public static boolean isBlank(final String str)
{
return (str == null) || str.isEmpty();
}
public static boolean isNotBlank(final String str)
{
return !StringUtils.isBlank(str);
}
public static boolean isEqual(final String s1, final String s2)
{
if (s1 == s2) { return true; }
if ((s1 == null) || (s2 == null)) { return false; }
return s1.equals(s2);
}
public static boolean isNotEqual(final String s1, final String s2)
{
return !StringUtils.isEqual(s1, s2);
}
Vous n'avez pas à utiliser de modèle de conception.
Initialise juste des variables lors de la déclaration. P>
E.g. P>
List<String> names = new ArrayList<String>(); Map<String,String> pairs = new HashMap<String,String>();
Avons-nous vraiment besoin d'un modèle pour le chèque de pointeur NULL? Utiliser quelque chose comme Util des communes ne devrait pas suffire?
"Évidemment une des plus grandes banes"? NullpointerExceptions sont l'un des problèmes de problèmes les plus faciles à diagnostiquer.
@thinkstep, si vous le faites beaucoup et un bon modèle peut être établi, alors c'est bénéfique. Ceci est particulièrement vrai si la façon dont il est normalement traité est verbeuse.
J'aimerais particulièrement éviter d'écrire: si ((a! = Null) && (a.getb ()! = Null) & (a.getb (). Getc ()! = Null)) {// Stuff}
@Michaelborgwardt Il est facile de diagnostiquer, mais il est courant et vous finissez par ajouter de nombreuses lignes à votre code pour l'éviter. En fait, c'est probablement la question qui exige que le code le plus supplémentaire soit adressé.