java pointer exception - Éviter! = Déclarations nulles




15 Answers

Pour moi, cela ressemble à un problème assez commun auquel les développeurs débutants à intermédiaires ont tendance à être confrontés à un moment donné: ils ne savent pas ou ne font pas confiance aux contrats auxquels ils participent et sur-vérifient de manière défensive la nullité. De plus, lorsqu'ils écrivent leur propre code, ils ont tendance à compter sur le renvoi de valeurs NULL pour indiquer quelque chose, ce qui oblige l'appelant à rechercher les valeurs NULL.

En d'autres termes, il y a deux cas où la vérification de null survient:

  1. Où null est une réponse valide en termes de contrat; et

  2. Où ce n'est pas une réponse valide.

(2) est facile. Utilisez des déclarations d' assert (assertions) ou autorisez un échec (par exemple, NullPointerException ). Les assertions sont une fonctionnalité Java très sous-utilisée ajoutée dans la version 1.4. La syntaxe est la suivante:

assert <condition>

ou

assert <condition> : <object>

<condition> est une expression booléenne et <object> est un objet dont la sortie de la méthode toString() sera incluse dans l'erreur.

Une instruction assert génère une Error ( AssertionError ) si la condition n'est pas vraie. Par défaut, Java ignore les assertions. Vous pouvez activer les assertions en transmettant l'option -ea à la machine -ea . Vous pouvez activer et désactiver des assertions pour des classes et des packages individuels. Cela signifie que vous pouvez valider le code avec les assertions lors du développement et des tests, et les désactiver dans un environnement de production, bien que mes tests n'aient montré aucun impact sur les performances des assertions.

Ne pas utiliser d'assertions dans ce cas est correct car le code va simplement échouer, ce qui se produira si vous utilisez des assertions. La seule différence est qu'avec les affirmations, cela peut arriver plus tôt, de manière plus significative et éventuellement avec des informations supplémentaires, ce qui peut vous aider à comprendre pourquoi cela s'est produit si vous ne vous y attendiez pas.

(1) est un peu plus difficile. Si vous n'avez aucun contrôle sur le code que vous appelez, vous êtes bloqué. Si null est une réponse valide, vous devez la vérifier.

Cependant, si c'est le code que vous contrôlez (et c'est souvent le cas), c'est une autre histoire. Évitez d’utiliser des valeurs NULL en réponse. Avec les méthodes qui renvoient des collections, rien de plus simple: renvoyez des collections vides (ou des tableaux) au lieu de null à peu près tout le temps.

Avec les non-collections, cela pourrait être plus difficile. Considérez ceci comme un exemple: si vous avez ces interfaces:

public interface Action {
  void doSomething();
}

public interface Parser {
  Action findAction(String userInput);
}

où Parser prend une entrée utilisateur brute et trouve quelque chose à faire, peut-être si vous implémentez une interface de ligne de commande pour quelque chose. Maintenant, vous pouvez indiquer au contrat qu'il renvoie la valeur null s'il n'y a pas d'action appropriée. Cela mène à la vérification de nullité dont vous parlez.

Une autre solution consiste à ne jamais renvoyer null et à utiliser le modèle d'objet Null :

public class MyParser implements Parser {
  private static Action DO_NOTHING = new Action() {
    public void doSomething() { /* do nothing */ }
  };

  public Action findAction(String userInput) {
    // ...
    if ( /* we can't find any actions */ ) {
      return DO_NOTHING;
    }
  }
}

Comparer:

Parser parser = ParserFactory.getParser();
if (parser == null) {
  // now what?
  // this would be an example of where null isn't (or shouldn't be) a valid response
}
Action action = parser.findAction(someInput);
if (action == null) {
  // do nothing
} else {
  action.doSomething();
}

à

ParserFactory.getParser().findAction(someInput).doSomething();

ce qui est une conception bien meilleure car elle conduit à un code plus concis.

Cela dit, il est peut-être tout à fait approprié que la méthode findAction () lève une exception avec un message d'erreur significatif, en particulier dans le cas où vous vous fiez à la saisie de l'utilisateur. Il serait bien mieux que la méthode findAction lève une exception plutôt que que la méthode appelante explose avec une simple exception NullPointerException sans explication.

try {
    ParserFactory.getParser().findAction(someInput).doSomething();
} catch(ActionNotFoundException anfe) {
    userConsole.err(anfe.getMessage());
}

Ou si vous pensez que le mécanisme try / catch est trop moche, plutôt que de ne rien faire, votre action par défaut devrait fournir un retour à l'utilisateur.

public Action findAction(final String userInput) {
    /* Code to return requested Action if found */
    return new Action() {
        public void doSomething() {
            userConsole.err("Action not found: " + userInput);
        }
    }
}
if test

J'utilise beaucoup object != null pour éviter NullPointerException .

Y a-t-il une bonne alternative à cela?

Par exemple:

if (someobject != null) {
    someobject.doCalc();
}

Cela évite une NullPointerException , lorsqu'il est inconnu si l'objet est null ou non.

Notez que la réponse acceptée peut être obsolète, voir https://.com/a/2386013/12943 pour une approche plus récente.




Si les valeurs nulles ne sont pas autorisées

Si votre méthode est appelée en externe, commencez par quelque chose comme ceci:

public void method(Object object) {
  if (object == null) {
    throw new IllegalArgumentException("...");
  }

Ensuite, dans le reste de cette méthode, vous saurez que cet object n'est pas nul.

S'il s'agit d'une méthode interne (ne faisant pas partie d'une API), indiquez simplement qu'elle ne peut pas être null, et c'est tout.

Exemple:

public String getFirst3Chars(String text) {
  return text.subString(0, 3);
}

Cependant, si votre méthode ne fait que transmettre la valeur, et que la méthode suivante la transmet, etc., cela pourrait devenir problématique. Dans ce cas, vous pouvez vérifier l'argument comme ci-dessus.

Si null est autorisé

Cela dépend vraiment. Si je trouve que je fais souvent quelque chose comme ça:

if (object == null) {
  // something
} else {
  // something else
}

Alors je branche, et fais deux choses complètement différentes. Il n'y a pas d'extrait de code laid, car je dois faire deux choses différentes en fonction des données. Par exemple, devrais-je travailler sur l'entrée ou devrais-je calculer une bonne valeur par défaut?

En fait, il est rare que j'utilise l'idiome " if (object != null && ... ").

Il sera peut-être plus facile de vous donner des exemples si vous montrez des exemples d'utilisation typique de cet idiome.




Si les valeurs non définies ne sont pas autorisées:

Vous pouvez configurer votre IDE pour vous avertir du possible déréférencement Null. Par exemple, dans Eclipse, voir Préférences> Java> Compilateur> Analyse des erreurs / avertissements / Null .

Si des valeurs non définies sont autorisées:

Si vous souhaitez définir une nouvelle API dans laquelle des valeurs non définies ont un sens , utilisez le modèle d'option (qui peut être familier des langages fonctionnels). Il présente les avantages suivants:

  • L'API indique explicitement si une entrée ou une sortie existe ou non.
  • Le compilateur vous oblige à gérer le cas "non défini".
  • L'option est une monade , il n'y a donc pas besoin de vérification verbale des valeurs nulles, utilisez simplement map / foreach / getOrElse ou un combinateur similaire pour utiliser la valeur en toute sécurité (example) .

Java 8 a une classe Optional intégrée (recommandée); pour les versions antérieures, il existe des alternatives de bibliothèque, par exemple, Optional ou Guava , Option . Mais comme beaucoup de modèles de styles fonctionnels, l’option Option en Java (même 8) donne un résultat assez sophistiqué, que vous pouvez réduire à l’aide d’un langage JVM moins détaillé, par exemple Scala ou Xtend.

Si vous devez utiliser une API pouvant renvoyer des valeurs NULL , vous ne pouvez pas faire grand-chose en Java. Xtend et Groovy ont l' opérateur Elvis ?: Et l' opérateur de déréférence null-safe ?. , mais notez que ceci retourne null dans le cas d’une référence null, donc il "diffère" le traitement approprié de null.




Avec Java 8, la nouvelle classe java.util.Optional apporte une solution au problème. On peut au moins dire que cela améliore la lisibilité du code et, dans le cas des API publiques, clarifie le contrat de l'API pour le développeur client.

Ils travaillent comme ça:

Un objet facultatif pour un type donné ( Fruit ) est créé en tant que type de retour d'une méthode. Il peut être vide ou contenir un objet Fruit :

public static Optional<Fruit> find(String name, List<Fruit> fruits) {
   for (Fruit fruit : fruits) {
      if (fruit.getName().equals(name)) {
         return Optional.of(fruit);
      }
   }
   return Optional.empty();
}

Maintenant, regardez ce code où nous recherchons une liste de Fruit ( fruits ) pour un exemple de fruit donné:

Optional<Fruit> found = find("lemon", fruits);
if (found.isPresent()) {
   Fruit fruit = found.get();
   String name = fruit.getName();
}

Vous pouvez utiliser l'opérateur map() pour effectuer un calcul - ou extraire une valeur - d'un objet facultatif. orElse() vous permet de fournir une solution de secours pour les valeurs manquantes.

String nameOrNull = find("lemon", fruits)
    .map(f -> f.getName())
    .orElse("empty-name");

Bien entendu, le contrôle de la valeur null / vide est toujours nécessaire, mais au moins le développeur est conscient du fait que la valeur peut être vide et que le risque d'oubli du contrôle est limité.

Dans une API créée à partir de zéro en utilisant Optional chaque fois qu'une valeur de retour peut être vide et renvoyant un objet brut uniquement lorsqu'il ne peut pas être null (convention), le code client peut abandonner les vérifications nulles sur les valeurs de retour d'objet simple ...

Bien sûr, Optional pourrait également être utilisé comme argument de méthode, peut-être un meilleur moyen d’indiquer des arguments optionnels que 5 ou 10 méthodes de surcharge dans certains cas.

Optional propose d'autres méthodes pratiques, telles que orElse qui permettent d'utiliser une valeur par défaut, et ifPresent qui fonctionne avec les expressions lambda .

Je vous invite à lire cet article (ma source principale pour la rédaction de cette réponse) dans lequel la problématique NullPointerException (et en général le pointeur null) ainsi que la solution (partielle) apportée par Optional sont bien expliquées: Objets facultatifs Java .




  • Si vous considérez qu'un objet ne doit pas être nul (ou s'il s'agit d'un bogue), utilisez une assertion.
  • Si votre méthode n'accepte pas les paramètres nuls, dites-le dans le fichier javadoc et utilisez une assertion.

Vous devez vérifier pour object! = Null que si vous souhaitez gérer le cas où l'objet peut être null ...

Il existe une proposition pour ajouter de nouvelles annotations dans Java7 afin d’aider les paramètres null / notnull: http://tech.puredanger.com/java7/#jsr308




Le cadre de gestion des collections de Google offre un moyen efficace et élégant de réaliser le contrôle nul.

Il y a une méthode dans une classe de bibliothèque comme ceci:

static <T> T checkNotNull(T e) {
   if (e == null) {
      throw new NullPointerException();
   }
   return e;
}

Et l'utilisation est (avec import static ):

...
void foo(int a, Person p) {
   if (checkNotNull(p).getAge() > a) {
      ...
   }
   else {
      ...
   }
}
...

Ou dans votre exemple:

checkNotNull(someobject).doCalc();



Plutôt que le motif d'objet Null (qui a ses utilisations), vous pouvez envisager des situations où l'objet null est un bogue.

Lorsque l'exception est levée, examinez la trace de la pile et corrigez le bogue.




Null n'est pas un "problème". Il fait partie intégrante d’un ensemble complete outils de modélisation. Le logiciel vise à modéliser la complexité du monde et à supporter son fardeau. Null indique "Pas de données" ou "Inconnu" en Java, etc. Il est donc approprié d'utiliser des valeurs NULL à ces fins. Je ne préfère pas le motif "Null object"; Je pense que cela soulève le problème " qui gardera les gardiens ".
Si vous me demandez quel est le nom de ma petite amie, je vous dirai que je n'ai pas de petite amie. Dans le langage Java, je retournerai null. Une alternative serait de lancer une exception significative pour indiquer un problème qui ne peut pas être (ou ne pasne voulez pas être) résolus sur-le-champ et déléguez-le quelque part plus haut dans la pile pour réessayer ou signaler une erreur d'accès aux données à l'utilisateur.

  1. Pour une "question inconnue", donnez "réponse inconnue". (Soyez null-safe lorsque cela est correct du point de vue commercial) Le fait de vérifier les arguments null une fois dans une méthode avant l'utilisation évite à plusieurs appelants de les vérifier avant un appel.

    public Photo getPhotoOfThePerson(Person person) {
        if (person == null)
            return null;
        // Grabbing some resources or intensive calculation
        // using person object anyhow.
    }
    

    Précédent mène au flux logique normal pour obtenir aucune photo d'une petite amie inexistante de ma photothèque.

    getPhotoOfThePerson(me.getGirlfriend())
    

    Et cela correspond à la nouvelle API Java à venir (regard vers l'avenir)

    getPhotoByName(me.getGirlfriend()?.getName())
    

    Bien que ce soit plutôt une "affaire normale" de ne pas trouver une photo stockée dans la base de données pour une personne, j'avais l'habitude d'utiliser des paires comme ci-dessous pour d'autres cas

    public static MyEnum parseMyEnum(String value); // throws IllegalArgumentException
    public static MyEnum parseMyEnumOrNull(String value);
    

    Et n'aimez pas taper <alt> + <shift> + <j>(générer javadoc dans Eclipse) et écrire trois mots supplémentaires pour votre API publique. Ce sera plus que suffisant pour tous sauf ceux qui ne lisent pas la documentation.

    /**
     * @return photo or null
     */
    

    ou

    /**
     * @return photo, never null
     */
    
  2. C’est un cas plutôt théorique et dans la plupart des cas, vous devriez préférer une API java null safe (au cas où elle sera publiée dans 10 ans), mais il NullPointerExceptions’agit d’une sous-classe d’un fichier Exception. Il s’agit donc d’une forme Throwablequi indique les conditions qu’une application raisonnable pourrait vouloir saisir ( javadoc )! Pour utiliser le premier avantage des exceptions et séparer le code de traitement des erreurs du code "normal" ( selon les créateurs de Java ), il convient, comme pour moi, de le détecter NullPointerException.

    public Photo getGirlfriendPhoto() {
        try {
            return appContext.getPhotoDataSource().getPhotoByName(me.getGirlfriend().getName());
        } catch (NullPointerException e) {
            return null;
        }
    }
    

    Des questions pourraient se poser:

    Q. Que faire si getPhotoDataSource()retourne null?
    A. Cela dépend de la logique métier. Si je ne parviens pas à trouver un album photo, je ne vous montrerai aucune photo. Et si appContext n'est pas initialisé? La logique métier de cette méthode résout ce problème. Si la même logique doit être plus stricte, une exception est générée dans la logique métier et une vérification explicite de null doit être utilisée (cas 3). La nouvelle API Java Null-safe s’adapte mieux ici pour spécifier de manière sélective ce qui implique et ce qui n’implique pas d’être initialisé pour éviter les erreurs de programmation.

    Q. Du code redondant peut être exécuté et des ressources inutiles peuvent être récupérées.
    A. Cela pourrait se produire si vous getPhotoByName()vouliez ouvrir une connexion de base de données, créer PreparedStatementet utiliser enfin le nom de la personne comme paramètre SQL. L'approche pour une question inconnue donne une réponse inconnue (cas 1) fonctionne ici. Avant de récupérer des ressources, la méthode doit vérifier les paramètres et renvoyer un résultat "inconnu" si nécessaire.

    Q. Cette approche entraîne une pénalité de performance en raison de l’ouverture de la fermeture de l’essai.
    A. Le logiciel doit être facile à comprendre et à modifier en premier lieu. Ce n’est qu’après cela que l’on pourrait penser à la performance, et seulement au besoin! et si nécessaire! ( source ) et beaucoup d’autres).

    PSCette approche sera aussi raisonnable à utiliser que le code de traitement des erreurs séparé du principe de code "normal" est raisonnable à utiliser dans certains endroits. Prenons l'exemple suivant:

    public SomeValue calculateSomeValueUsingSophisticatedLogic(Predicate predicate) {
        try {
            Result1 result1 = performSomeCalculation(predicate);
            Result2 result2 = performSomeOtherCalculation(result1.getSomeProperty());
            Result3 result3 = performThirdCalculation(result2.getSomeProperty());
            Result4 result4 = performLastCalculation(result3.getSomeProperty());
            return result4.getSomeProperty();
        } catch (NullPointerException e) {
            return null;
        }
    }
    
    public SomeValue calculateSomeValueUsingSophisticatedLogic(Predicate predicate) {
        SomeValue result = null;
        if (predicate != null) {
            Result1 result1 = performSomeCalculation(predicate);
            if (result1 != null && result1.getSomeProperty() != null) {
                Result2 result2 = performSomeOtherCalculation(result1.getSomeProperty());
                if (result2 != null && result2.getSomeProperty() != null) {
                    Result3 result3 = performThirdCalculation(result2.getSomeProperty());
                    if (result3 != null && result3.getSomeProperty() != null) {
                        Result4 result4 = performLastCalculation(result3.getSomeProperty());
                        if (result4 != null) {
                            result = result4.getSomeProperty();
                        }
                    }
                }
            }
        }
        return result;
    }
    

    PPS. Pour ceux qui ont le moins de voix possible (et pas si vite pour lire la documentation), je voudrais dire que je n'ai jamais attrapé d'exception de pointeur nul (NPE) dans ma vie. Mais cette possibilité a été intentionnellement conçue par les créateurs de Java, car NPE est une sous-classe de Exception. Nous avons un précédent dans l’histoire de Java quand ce ThreadDeathn’est Errorpas parce qu’il s’agit d’une erreur d’application, mais uniquement parce que cela n’a pas été prévu! Combien de NPE convient pour être un Errorque ThreadDeath! Mais ce n'est pas.

  3. Recherchez «Pas de données» uniquement si la logique métier l’implique.

    public void updatePersonPhoneNumber(Long personId, String phoneNumber) {
        if (personId == null)
            return;
        DataSource dataSource = appContext.getStuffDataSource();
        Person person = dataSource.getPersonById(personId);
        if (person != null) {
            person.setPhoneNumber(phoneNumber);
            dataSource.updatePerson(person);
        } else {
            Person = new Person(personId);
            person.setPhoneNumber(phoneNumber);
            dataSource.insertPerson(person);
        }
    }
    

    et

    public void updatePersonPhoneNumber(Long personId, String phoneNumber) {
        if (personId == null)
            return;
        DataSource dataSource = appContext.getStuffDataSource();
        Person person = dataSource.getPersonById(personId);
        if (person == null)
            throw new SomeReasonableUserException("What are you thinking about ???");
        person.setPhoneNumber(phoneNumber);
        dataSource.updatePerson(person);
    }
    

    Si appContext ou dataSource n'est pas initialisé, le runtime non géré NullPointerException supprimera le thread actuel et sera traité par Thread.defaultUncaughtExceptionHandler (pour que vous définissiez et Thread.defaultUncaughtExceptionHandler votre enregistreur favori ou un autre Thread.defaultUncaughtExceptionHandler notification). S'il n'est pas défini, ThreadGroup#uncaughtException uncaughtException imprimera stacktrace avec une erreur système. Il faut surveiller le journal des erreurs d’application et ouvrir le problème Jira pour chaque exception non gérée qui est en fait une erreur d’application. Le programmeur devrait corriger un bogue quelque part dans l'initialisation.




"Problème" commun en Java en effet.

Tout d'abord, mes pensées à ce sujet:

Je considère qu'il est mauvais de "manger" quelque chose lorsque NULL a été passé, où NULL n'est pas une valeur valide. Si vous ne quittez pas la méthode avec une sorte d'erreur, cela signifie que rien ne s'est mal passé dans votre méthode, ce qui n'est pas vrai. Ensuite, vous renvoyez probablement null dans ce cas, et dans la méthode de réception, vous recherchez à nouveau la valeur null, elle ne se termine jamais et vous obtenez "if! = Null", etc.

Ainsi, IMHO, null doit être une erreur critique empêchant toute exécution ultérieure (c'est-à-dire, où null n'est pas une valeur valide).

Voici comment je résous ce problème:

Tout d'abord, je suis cette convention:

  1. Toutes les méthodes publiques / API vérifient toujours ses arguments pour null
  2. Toutes les méthodes privées ne vérifient pas la valeur null car ce sont des méthodes contrôlées (laissez mourir avec l'exception nullpointer au cas où cela n'aurait pas été traité ci-dessus)
  3. Les seules autres méthodes qui ne vérifient pas la valeur null sont les méthodes utilitaires. Ils sont publics, mais si vous les appelez pour une raison quelconque, vous savez quels paramètres vous transmettez. C'est comme essayer de faire bouillir de l'eau dans la bouilloire sans fournir d'eau ...

Et enfin, dans le code, la première ligne de la méthode publique est la suivante:

ValidationUtils.getNullValidator().addParam(plans, "plans").addParam(persons, "persons").validate();

Notez que addParam () renvoie self, ce qui vous permet d'ajouter plus de paramètres à vérifier.

La méthode validate()jettera coché ValidationExceptionsi l'un des paramètres est nul (coché ou décoché, c'est plutôt un problème de conception / goût, mais ma ValidationExceptionest coché).

void validate() throws ValidationException;

Le message contiendra le texte suivant si, par exemple, "plans" est null:

" La valeur de l'argument non valide est nulle pour le paramètre [plans] "

Comme vous pouvez le constater, la deuxième valeur de la méthode addParam () (chaîne) est nécessaire pour le message de l'utilisateur, car vous ne pouvez pas facilement détecter le nom de la variable transmise, même avec réflexion (ce n'est pas le cas de l'objet de cette publication ...).

Et oui, nous savons qu'au-delà de cette ligne, nous ne rencontrerons plus de valeur nulle. Nous invoquerons donc en toute sécurité des méthodes sur ces objets.

De cette façon, le code est propre, facile à gérer et lisible.




En plus d'utiliser, assertvous pouvez utiliser les éléments suivants:

if (someobject == null) {
    // Handle null here then move on.
}

C'est légèrement mieux que:

if (someobject != null) {
    .....
    .....



    .....
}



Guava, une bibliothèque de base très utile de Google, possède une API intéressante et utile pour éviter les valeurs nulles. Je trouve Guava très utile.

Comme expliqué dans le wiki:

Optional<T>est un moyen de remplacer une référence T nullable par une valeur non nulle. Un facultatif peut soit contenir une référence T non nulle (auquel cas nous disons que la référence est "présente"), soit ne rien contenir (dans ce cas, nous dirons que la référence est "absente"). Il n'est jamais dit de "contenir null".

Usage:

Optional<Integer> possible = Optional.of(5);
possible.isPresent(); // returns true
possible.get(); // returns 5



J'aime les articles de Nat Pryce. Voici les liens:

Dans les articles, il y a également un lien vers un référentiel Git pour un type Java Maybe que je trouve intéressant, mais je ne pense pas que cela seul puisse réduire le fardeau de vérification du code. Après avoir fait des recherches sur Internet, je pense que ! = Le code vide peut être réduit principalement par une conception soignée.




La meilleure alternative pour Java 8 ou plus récent est probablement d'utiliser la Optionalclasse.

Optional stringToUse = Optional.of("optional is there");
stringToUse.ifPresent(System.out::println);

Ceci est particulièrement utile pour les longues chaînes de valeurs null possibles. Exemple:

Optional<Integer> i = Optional.ofNullable(wsObject.getFoo())
    .map(f -> f.getBar())
    .map(b -> b.getBaz())
    .map(b -> b.getInt());

Exemple sur la façon de lancer une exception sur null:

Optional optionalCarNull = Optional.ofNullable(someNull);
optionalCarNull.orElseThrow(IllegalStateException::new);

Java 7 a introduit la Objects.requireNonNullméthode qui peut être utile lorsque quelque chose doit être vérifié pour la non-nullité. Exemple:

String lowerVal = Objects.requireNonNull(someVar, "input cannot be null or empty").toLowerCase();



J'ignore fortement les réponses qui suggèrent d'utiliser les objets nuls dans chaque situation. Ce modèle peut rompre le contrat et enfouir les problèmes de plus en plus profond au lieu de les résoudre, sans mentionner que leur utilisation inappropriée créera une autre pile de code passe-partout qui nécessitera un entretien ultérieur.

En réalité, si quelque chose retourné par une méthode peut être nul et que le code appelant doit prendre une décision à ce sujet, un appel précédent garantissant l'état.

N'oubliez pas non plus que ce modèle d'objet nul aura besoin de beaucoup de mémoire s'il est utilisé sans précaution. Pour cela, l'instance d'un NullObject doit être partagée entre les propriétaires et ne pas être une instance unigue pour chacun d'eux.

De plus, je ne recommanderais pas l'utilisation de ce modèle où le type est censé être une représentation de type primitif - comme les entités mathématiques, qui ne sont pas des scalaires: vecteurs, matrices, nombres complexes et objets POD (Plain Old Data), destinés à conserver l'état sous forme de types Java intégrés. Dans ce dernier cas, vous appelez des méthodes getter avec des résultats arbitraires. Par exemple, que devrait renvoyer une méthode NullPerson.getName ()?

Cela vaut la peine d’envisager de tels cas afin d’éviter des résultats absurdes.




C'est l'erreur la plus commune survenue pour la plupart des développeurs.

Nous avons plusieurs façons de gérer cela.

Approche 1:

org.apache.commons.lang.Validate //using apache framework

notNull (objet Object, message String)

Approche 2:

if(someObject!=null){ // simply checking against null
}

Approche 3:

@isNull @Nullable  // using annotation based validation

Approche 4:

// by writing static method and calling it across whereever we needed to check the validation

static <T> T isNull(someObject e){  
   if(e == null){
      throw new NullPointerException();
   }
   return e;
}



Related