Est Attraper une Exception de Pointeur Null une Odeur de Code?

Je pense exactement une utilisation pour jamais attraper un NullPointerException:

catch (NullPointerException) {
    ApplyPainfulElectricShockToProgrammer();
}

Il dépend.

La façon connu ce collègue? Est-il de le faire pour de l'ignorance/la paresse ou est-il une vraie bonne raison pour cela? ( comme c'est le thread principal au-dessus de tout le reste et ne devrait jamais mourir? )

90% du temps d'attraper une exception d'exécution est faux, 99% de la capture d'une NullPointerException est faux ( si la raison en est "je recevais beaucoup d'entre eux...", puis l'ensemble de programmeur est faux et vous devriez regarder prendre soin pour le reste du code, il a à faire )

Mais dans certaines circonstances, d'attraper un NullPointerException peut être acceptable.

Drôle

Je viens de trouver quelque chose qui ne devrait pas être fait au travail:

public static boolean isValidDate(final String stringDateValue) {
    String exp = "^[0-9]{2}/[0-9]{2}/[0-9]{4}$";
    boolean isValid = false;
    try {
        if (Pattern.matches(exp, stringDateValue)) {
            String[] dateArray = stringDateValue.split("/");
            if (dateArray.length == 3) {
                GregorianCalendar gregorianCalendar = new GregorianCalendar();
                int annee = new Integer(dateArray[2]).intValue();
                int mois = new Integer(dateArray[1]).intValue();
                int jour = new Integer(dateArray[0]).intValue();

                gregorianCalendar = new GregorianCalendar(annee, mois - 1,
                        jour);
                gregorianCalendar.setLenient(false);
                gregorianCalendar.get(GregorianCalendar.YEAR);
                gregorianCalendar.get(GregorianCalendar.MONTH);
                gregorianCalendar.get(GregorianCalendar.DAY_OF_MONTH);
                isValid = true;
            }
        }
    } catch (Exception e) {
        isValid = false;
    }
    return isValid;
}

baaad 🙂

Le développeur a voulu le calendrier de lever des exceptions de ce genre:

java.lang.IllegalArgumentException: DAY_OF_MONTH
    at java.util.GregorianCalendar.computeTime(GregorianCalendar.java:2316)
    at java.util.Calendar.updateTime(Calendar.java:2260)
    at java.util.Calendar.complete(Calendar.java:1305)
    at java.util.Calendar.get(Calendar.java:1088)

d'invalider les valeurs...

Oui, il fonctionne, mais ce n'est pas vraiment une bonne pratique...

Levée de l'exception (en particulier le remplissage de la trace de la pile) coût beaucoup plus que la simple vérification des données manuellement sans exception...

Il est certainement.

La plupart du temps, les variables ne devrait pas être null pour commencer. Beaucoup de nouvelles langues sont à venir avec la prise en charge intégrée pour les non nullable types de référence, -- c'est les types qui sont la garantie de ne jamais être null.

Pour les moments où votre valeur entrante est autorisé à être null, vous devez faire un chèque. Mais des exceptions sont définitivement une mauvaise façon de le faire.

Une instruction if faut peut-être trois instructions à exécuter et est une vérification locale (c'est à dire, faire le chèque au même endroit que vous avez besoin de la garantie).

L'aide d'une exception, d'autre part, peut prendre beaucoup plus d'instructions -- le système tente de chercher la méthode, ne parvient pas, regarde à travers la table d'exception pour le gestionnaire d'exception, sauts il y, exécute le gestionnaire, et les sauts de nouveau. En outre, la vérification est potentiellement non-local. Si votre code est quelque chose comme ceci:

try
  return contacts.find("Mom").getEmail()
catch (NullPointerException e)
  return null

Vous ne savez pas si le NPE a été jeté dans 'getEmail" ou dans "rechercher".

Une technique pire solution à un très, très commun que les écrits en plus obscurci façon? Il n'est pas de rang, mais ça sent mauvais :/

Attraper une exception de pointeur NULL dépend vraiment du contexte ... on devrait s'efforcer d'éviter les strictes règles absolues ... règles doivent être appliquées dans le contexte voulez piège de cette exception et mettre l'ensemble du logiciel dans certains état STABLE, de ne rien faire ou presque à côté de rien. Toutes ces règles de codage doivent être bien compris

À ce stade, vous regardez alors votre logiciel de TRACE d'AUDIT ... que vous devriez faire et à découvrir la SOURCE de cette exception.

L'idée qu'une Exception de Pointeur NULL Ne sera Jamais Survenir doivent être vérifiables. D'abord faire une analyse statique ... (ce qui est plus difficile si la 3ème partie du code/composants venir) et ensuite faire une liste exhaustive de l'état de l'espace de recherche en utilisant les outils appropriés.

x

Quoi à ce sujet:

try
{
    foo.x = bar;
}
catch (NullPointerException e)
{
    //do whatever needs to be done
}

comme un micro-optimisation de foo peut être nulle, mais presque jamais?

L'idée est la suivante:

• Une valeur NULL explicite de vérifier, à partir d'une instruction machine

• D'autre part, la valeur NULL est à vérifier dans la deuxième version peut être fait en laissant le NUL accès, la capture de la SIGSEGV, et en jetant un NullPointerException. C'est gratuit si l'objet n'est pas NULL.

J'essaie de garantir les résultats de mes interfaces, mais si une bibliothèque ou quelqu'code peut produire de la valeur null comme un résultat et im attend à une garantie de la capture, il pourrait être viable. Bien sûr, ce que vous faites une fois que vous attraper, il est à vous. Parfois il ne fait pas de sens pour vérifier la valeur null, et si vous l'attrapez vous avez une autre méthode de résolution de problème qui pourrait ne pas être aussi bonne, mais fait le travail.

Ce que je dis est l'utilisation d'exceptions pour ce que vous pouvez, c'est une assez bonne fonctionnalité du langage.

Cela dépend vraiment de la définition de l'interface. Non structurées NPE la manipulation est aussi mauvais que la capture d'Exception ou de Throwable.

Les valeurs null sont utiles pour l'identification d'un état non initialisé plutôt que d'utiliser une chaîne vide ou max_int ou quoi que ce soit. Une fois à l'endroit où je utiliser la valeur null est régulièrement dans les endroits où un objet de rappel n'est pas pertinent.

J'aime vraiment le @Nullable annotations fournies par Guice.

http://code.google.com/docreader/#p=google-guice&s=google guice&t=UseNullable

Pour éliminer NullPointerExceptions dans
votre base de code, vous devez être discipliné
à propos des références nulles. Nous avons été
couronnée de succès à cette par la suite et
l'application d'une règle simple:

Chaque paramètre est non nulle, à moins que
explicitement spécifié. Google
Les Collections de la bibliothèque et de la JSR-305 ont
Api simple pour obtenir un null en vertu de
de contrôle. Conditions préalables.checkNotNull
peut être utilisé pour rapide échouer si une valeur null
référence est trouvée, et @Nullable peut
être utilisé pour annoter un paramètre qui
permis la valeur null.

Guice interdit la valeur null par défaut. Il
refuser d'injecter null, à défaut avec une
ProvisionException à la place. Si la valeur null est
autorisée par votre classe, vous pouvez
annoter le champ de paramètre ou avec
@Nullable. Guice reconnaît tout
@Nullable annotation, comme
edu.umd.cs.findbugs.les annotations.Nullable
ou javax.annotation.Nullable.

Si le programmeur est un débutant, il peut avoir l'habitude d'attraper tous les exception qui s'arrête de lui pour obtenir le résultat final. Cela ne devrait pas être diverti par le code des réviseurs.

Attraper des RuntimeException est mauvais. Mais si cela est vraiment nécessaire, puis un commentaire dans le code sera vraiment utile pour les futurs programmeurs qui travaillent sur le code. Si vous ne pouvez pas écrire un raisonnable commentaire pour les attraper, alors vous devez éviter. période.