Éviter les instructions! = Null

J'utilise object != nullbeaucoup pour éviter NullPointerException.

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

Par exemple, j'utilise souvent:

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

Cela recherche un NullPointerExceptionpour l' someobjectobjet dans l'extrait ci-dessus.

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

Pour moi, cela ressemble à un problème assez courant auquel les développeurs juniors à intermédiaires ont tendance à faire face à un moment donné: ils ne connaissent pas ou ne font pas confiance aux contrats auxquels ils participent et vérifient de manière défensive les null. De plus, lors de l'écriture de leur propre code, ils ont tendance à compter sur le retour de null pour indiquer quelque chose, ce qui oblige l'appelant à vérifier les null.

Pour le dire autrement, il y a deux cas où la vérification nulle apparaît:

1. Lorsque null est une réponse valable en termes de contrat; et

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

(2) est facile. Utilisez des assertinstructions (assertions) ou autorisez l'échec (par exemple, NullPointerException ). Les assertions sont une fonctionnalité Java très sous-utilisée qui a été ajoutée dans 1.4. La syntaxe est:

assert <condition>

ou

assert <condition> : <object>

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

Une assertinstruction renvoie un 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 JVM. Vous pouvez activer et désactiver les 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é pratiquement aucun impact sur les performances des assertions.

Ne pas utiliser d'assertions dans ce cas est correct car le code échouera, ce qui se produira si vous utilisez des assertions. La seule différence est qu'avec les assertions, cela pourrait arriver plus tôt, d'une manière plus significative et éventuellement avec des informations supplémentaires, ce qui pourrait 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.

Si c'est du code que vous contrôlez cependant (et c'est souvent le cas), alors c'est une autre histoire. Évitez d'utiliser des valeurs nulles comme réponse. Avec les méthodes qui retournent des collections, c'est facile: renvoyez des collections vides (ou tableaux) au lieu de null à peu près tout le temps.

Avec des 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 les entrées utilisateur brutes et trouve quelque chose à faire, peut-être si vous implémentez une interface de ligne de commande pour quelque chose. Vous pouvez maintenant rendre le contrat qu'il renvoie nul s'il n'y a aucune action appropriée. Cela mène à la vérification nulle dont vous parlez.

Une solution alternative consiste à ne jamais retourner null et à utiliser à la place le modèle Null Object :

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 bien meilleure conception 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 ce cas où vous comptez sur une entrée utilisateur. Il serait beaucoup mieux pour la méthode findAction de lever une exception que pour la méthode appelante de sauter avec une simple 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 laid, plutôt que Ne rien faire, votre action par défaut devrait fournir des commentaires à 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);
        }
    }
}

Si vous utilisez (ou prévoyez d'utiliser) un IDE Java comme JetBrains IntelliJ IDEA , Eclipse ou Netbeans ou un outil comme findbugs, vous pouvez utiliser des annotations pour résoudre ce problème.

Fondamentalement, vous avez @Nullableet @NotNull.

Vous pouvez utiliser dans la méthode et les paramètres, comme ceci:

@NotNull public static String helloWorld() {
    return "Hello World";
}

ou

@Nullable public static String helloWorld() {
    return "Hello World";
}

Le deuxième exemple ne se compilera pas (dans IntelliJ IDEA).

Lorsque vous utilisez la première helloWorld()fonction dans un autre morceau de code:

public static void main(String[] args)
{
    String result = helloWorld();
    if(result != null) {
        System.out.println(result);
    }
}

Maintenant, le compilateur IntelliJ IDEA vous dira que la vérification est inutile, car la helloWorld()fonction ne reviendra nulljamais.

Utilisation d'un paramètre

void someMethod(@NotNull someParameter) { }

si vous écrivez quelque chose comme:

someMethod(null);

Cela ne se compilera pas.

Dernier exemple utilisant @Nullable

@Nullable iWantToDestroyEverything() { return null; }

Ce faisant

iWantToDestroyEverything().something();

Et vous pouvez être sûr que cela n'arrivera pas. :)

C'est un bon moyen de laisser le compilateur vérifier quelque chose de plus qu'il ne le fait habituellement et de faire en sorte que vos contrats soient plus forts. Malheureusement, il n'est pas pris en charge par tous les compilateurs.

Dans IntelliJ IDEA 10.5 et versions ultérieures, ils ont ajouté la prise en charge de toutes les autres @Nullable @NotNullimplémentations.

Voir l'article de blog Annotations @ Nullable / @ NotNull plus flexibles et configurables .

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 ce objectn'est pas nul.

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

Exemple:

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

Cependant, si votre méthode transmet simplement la valeur et que la méthode suivante la transmet, etc., cela peut 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
}

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

Il est en fait rare que j'utilise l'idiome " if (object != null && ...".

Il peut être plus facile de vous donner des exemples si vous montrez des exemples où vous utilisez généralement l'idiome.

Wow, je déteste presque ajouter une autre réponse lorsque nous avons 57 façons différentes de recommander le NullObject pattern, mais je pense que certaines personnes intéressées par cette question aimeraient savoir qu'il y a une proposition sur la table pour Java 7 d'ajouter "null-safe" manipulation " - une syntaxe simplifiée pour la logique if-not-equal-null.

L'exemple donné par Alex Miller ressemble à ceci:

public String getPostcode(Person person) {  
  return person?.getAddress()?.getPostcode();  
}  

Le ?.moyen ne dé-référence l'identifiant gauche que s'il n'est pas nul, sinon évaluez le reste de l'expression comme null. Certaines personnes, comme le membre de Java Posse, Dick Wall, et les électeurs de Devoxx aiment vraiment cette proposition, mais il y a aussi une opposition, au motif qu'elle encouragera en fait une plus grande utilisation de la nullvaleur sentinelle.

Mise à jour: une proposition officielle pour un opérateur null-safe dans Java 7 a été soumise sous Project Coin. La syntaxe est un peu différente de l'exemple ci-dessus, mais c'est la même notion.

Mise à jour: la proposition d'opérateur null-safe n'est pas entrée dans Project Coin. Vous ne verrez donc pas cette syntaxe dans Java 7.

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

Vous pouvez configurer votre IDE pour vous avertir d'un éventuel déréférencement nul. Par exemple, dans Eclipse, voir Préférences> Java> Compilateur> Erreurs / Avertissements / Analyse nulle .

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

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

• Il est indiqué explicitement dans l'API 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 nulle verbeuse, utilisez simplement map / foreach / getOrElse ou un combinateur similaire pour utiliser la valeur en toute sécurité (exemple) .

Java 8 a une Optionalclasse intégrée (recommandée); pour les versions antérieures, il existe des alternatives bibliothèque, par exemple goyave « s Optionalou FunctionalJava d » Option. Mais comme de nombreux modèles de style fonctionnel, l'utilisation d'Option en Java (même 8) donne lieu à un certain nombre de références, que vous pouvez réduire en utilisant un langage JVM moins verbeux, par exemple Scala ou Xtend.

Si vous devez gérer une API qui peut renvoyer des valeurs nulles , 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 cela retourne null dans le cas d'une référence null, donc il "diffère" juste le traitement correct de null.

Seulement pour cette situation -

Ne pas vérifier si une variable est nulle avant d'invoquer une méthode equals (un exemple de comparaison de chaîne ci-dessous):

if ( foo.equals("bar") ) {
 // ...
}

entraînera un NullPointerExceptionsi foon'existe pas.

Vous pouvez éviter cela si vous comparez les vôtres Stringcomme ceci:

if ( "bar".equals(foo) ) {
 // ...
}

Avec Java 8 vient la nouvelle java.util.Optionalclasse qui résout sans doute une partie du problème. On peut au moins dire que cela améliore la lisibilité du code et, dans le cas des API publiques, rendre le contrat de l'API plus clair pour le développeur client.

Ils fonctionnent comme ça:

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

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();
}

Regardez maintenant ce code où nous recherchons une liste de Fruit( fruits) pour une instance de Fruit donnée:

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

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

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

Bien sûr, la vérification de la valeur nulle / vide est toujours nécessaire, mais au moins le développeur est conscient que la valeur peut être vide et le risque d'oublier de vérifier est limité.

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

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

Optionalpropose d'autres méthodes pratiques, telles que celles orElsequi permettent l'utilisation d'une valeur par défaut, et ifPresentqui fonctionnent avec les expressions lambda .

Je vous invite à lire cet article (ma principale source d'écriture de cette réponse) dans lequel la NullPointerExceptionproblématique (et en général le pointeur nul) ainsi que la solution (partielle) apportée Optionalsont bien expliquées: Java Optional Objects .

Selon le type d'objets que vous vérifiez, vous pourrez peut-être utiliser certaines des classes dans les collections apache commons telles que: collections apache commons lang et apache commons

Exemple:

String foo;
...
if( StringUtils.isBlank( foo ) ) {
   ///do something
}

ou (selon ce que vous devez vérifier):

String foo;
...
if( StringUtils.isEmpty( foo ) ) {
   ///do something
}

La classe StringUtils n'est que l'une des nombreuses; il y a pas mal de bonnes classes dans les communs qui font des manipulations sûres nulles.

Voici un exemple de la façon dont vous pouvez utiliser la vallidation nulle dans JAVA lorsque vous incluez la bibliothèque apache (commons-lang-2.4.jar)

public DOCUMENT read(String xml, ValidationEventHandler validationEventHandler) {
    Validate.notNull(validationEventHandler,"ValidationHandler not Injected");
    return read(new StringReader(xml), true, validationEventHandler);
}

Et si vous utilisez Spring, Spring a également la même fonctionnalité dans son package, voir bibliothèque (spring-2.4.6.jar)

Exemple d'utilisation de cette classe statique à partir du printemps (org.springframework.util.Assert)

Assert.notNull(validationEventHandler,"ValidationHandler not Injected");

• 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 javadoc et utilisez une assertion.

Vous devez vérifier l'objet! = Null uniquement si vous voulez gérer le cas où l'objet peut être nul ...

Il est proposé d'ajouter de nouvelles annotations dans Java7 pour aider avec les paramètres null / notnull: http://tech.puredanger.com/java7/#jsr308

Je suis fan du code "fail fast". Demandez-vous - faites-vous quelque chose d'utile dans le cas où le paramètre est nul? Si vous n'avez pas de réponse claire à ce que votre code devrait faire dans ce cas ... C'est-à-dire qu'il ne devrait jamais être nul en premier lieu, alors ignorez-le et autorisez une NullPointerException à être levée. Le code appelant aura autant de sens pour un NPE que pour une exception IllegalArgumentException, mais il sera plus facile pour le développeur de déboguer et de comprendre ce qui s'est passé si un NPE est lancé plutôt que votre code tentant d'exécuter une autre contingence inattendue logique - ce qui entraîne finalement l'échec de l'application de toute façon.

Le cadre des collections Google offre un moyen efficace et élégant de réaliser la vérification nulle.

Il existe une méthode dans une classe de bibliothèque comme celle-ci:

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();

Parfois, vous avez des méthodes qui opèrent sur ses paramètres qui définissent une opération symétrique:

a.f(b); <-> b.f(a);

Si vous savez que b ne peut jamais être nul, vous pouvez simplement l'échanger. Il est très utile pour les égaux: au lieu de foo.equals("bar");faire mieux "bar".equals(foo);.

Plutôt que Null Object Pattern - qui a ses utilisations - vous pourriez envisager des situations où l'objet nul est un bogue.

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

Null n'est pas un «problème». Il fait partie intégrante d'un ensemble complet d' outils de modélisation. Le logiciel vise à modéliser la complexité du monde et null porte son fardeau. Null indique «Aucune donnée» ou «Inconnu» en Java et similaires. Il est donc approprié d'utiliser des valeurs nulles à ces fins. Je ne préfère pas le motif «objet nul»; 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 lever une exception significative pour indiquer un problème qui ne peut pas être (ou ne pas ''

1. Pour une «question inconnue», donnez «réponse inconnue». (Assurez-vous que la valeur NULL est correcte du point de vue commercial) La vérification des arguments NULL une fois à l'intérieur d'une méthode avant 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.
   }

   Le précédent conduit à un flux logique normal pour ne pas obtenir de photo d'une petite amie inexistante de ma photothèque.

   getPhotoOfThePerson(me.getGirlfriend())

   Et il correspond à la nouvelle API Java à venir (pour l'avenir)

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

   Bien qu'il soit plutôt `` flux commercial normal '' de ne pas trouver de photo stockée dans la base de données pour une personne, j'ai utilisé des paires comme ci-dessous pour d'autres cas

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

   Et ne détestez 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 pour 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 l'API java null safe (au cas où elle serait publiée dans 10 ans), mais NullPointerExceptionc'est une sous-classe d'un Exception. C'est donc une forme Throwablequi indique les conditions qu'une application raisonnable pourrait vouloir attraper ( javadoc )! Pour utiliser le premier avantage des exceptions et séparer le code de gestion des erreurs du code «normal» ( selon les créateurs de Java ), il est approprié, comme pour moi, d'attraper NullPointerException.

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

   Des questions pourraient se poser:

   Q. Et si getPhotoDataSource()renvoie null?
   R. Cela dépend de la logique métier. Si je ne trouve pas d'album photo, je ne vous montrerai aucune photo. Que faire si appContext n'est pas initialisé? La logique métier de cette méthode supporte cela. Si la même logique doit être plus stricte que de lancer une exception, elle fait partie de 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 sélectivement ce qui implique et ce qui n'implique pas d'être initialisé pour être rapide en cas d'erreurs de programmation.

   Q. Du code redondant pourrait être exécuté et des ressources inutiles pourraient être récupérées.
   A. Cela pourrait avoir lieu si getPhotoByName()j'essayais d'ouvrir une connexion à une base de données, de créer PreparedStatementet d'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 retourner un résultat «inconnu» si nécessaire.

   Q. Cette approche a une pénalité de performance en raison de l'ouverture de fermeture d'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 aux performances, et seulement si nécessaire! et là où c'est nécessaire! ( source ), et bien d'autres).

   PS. Cette approche sera aussi raisonnable à utiliser que le code de gestion d'erreurs distinct du principe de code "normal" est raisonnable à utiliser à un certain endroit. 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 souhaitent voter rapidement (et pas si rapidement pour lire la documentation), je voudrais dire que je n'ai jamais détecté d'exception de pointeur nul (NPE) dans ma vie. Mais cette possibilité a été intentionnellement conçue par les créateurs 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 le cas car il s'agit en fait d'une erreur d'application, mais uniquement parce qu'il n'était pas destiné à être rattrapé! Combien de NPE convient pour être un Errorque ThreadDeath! Mais ce n'est pas.

3. Cochez «Aucune donnée» uniquement si la logique métier le sous-entend.

   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 tuera le thread actuel et sera traité par Thread.defaultUncaughtExceptionHandler (pour que vous puissiez définir et utiliser votre enregistreur préféré ou un autre mécanisme de notification). S'il n'est pas défini, ThreadGroup # uncaughtException imprime stacktrace à l'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 le bogue quelque part dans les trucs d'initialisation.

Java 7 a une nouvelle java.util.Objectsclasse utilitaire sur laquelle il existe une requireNonNull()méthode. Tout cela ne fait que lancer un NullPointerExceptionsi son argument est nul, mais il nettoie un peu le code. Exemple:

Objects.requireNonNull(someObject);
someObject.doCalc();

La méthode est très utile pour vérifier juste avant une affectation dans un constructeur, où chaque utilisation de celle-ci peut enregistrer trois lignes de code:

Parent(Child child) {
   if (child == null) {
      throw new NullPointerException("child");
   }
   this.child = child;
}

devient

Parent(Child child) {
   this.child = Objects.requireNonNull(child, "child");
}

En fin de compte, la seule façon de résoudre complètement ce problème est d'utiliser un langage de programmation différent:

• Dans Objective-C, vous pouvez faire l'équivalent d'invoquer une méthode nilet absolument rien ne se passera. Cela rend la plupart des contrôles nuls inutiles, mais cela peut rendre les erreurs beaucoup plus difficiles à diagnostiquer.
• A Nice , un langage dérivé de Java, il existe deux versions de tous types: une version potentiellement nulle et une version non nulle. Vous ne pouvez appeler des méthodes que sur des types non nuls. Les types potentiellement nuls peuvent être convertis en types non nuls grâce à une vérification explicite de null. Cela permet de savoir plus facilement où les vérifications nulles sont nécessaires et où elles ne le sont pas.

"Problème" commun en Java en effet.

Tout d'abord, mes réflexions à ce sujet:

Je considère qu'il est mauvais de "manger" quelque chose lorsque NULL a été passé alors que 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 retournez probablement null dans ce cas, et dans la méthode de réception, vous vérifiez à nouveau pour null, et cela ne se termine jamais, et vous vous retrouvez avec "if! = Null", etc.

Donc, à mon humble avis, null doit être une erreur critique qui empêche toute exécution ultérieure (c'est-à-dire où null n'est pas une valeur valide).

La façon dont je résous ce problème est la suivante:

Tout d'abord, je respecte cette convention:

1. Toutes les méthodes / API publiques vérifient toujours ses arguments pour null
2. Toutes les méthodes privées ne vérifient pas null car ce sont des méthodes contrôlées (laissez simplement mourir avec l'exception nullpointer au cas où cela ne serait pas géré 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 passez. 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 se présente comme suit:

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

Notez que addParam () renvoie self, afin que vous puissiez ajouter plus de paramètres à vérifier.

La méthode validate()lancera vérifié ValidationExceptionsi l'un des paramètres est nul (coché ou décoché est plus un problème de conception / goût, mais mon ValidationExceptionest vérifié).

void validate() throws ValidationException;

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

"Une valeur d'argument non valide est rencontrée pour le paramètre [plans] "

Comme vous pouvez le voir, la deuxième valeur de la méthode (chaîne) addParam () est nécessaire pour le message utilisateur, car vous ne pouvez pas facilement détecter le nom de variable transmise, même avec réflexion (de toute façon pas l'objet de cet article ...).

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

De cette façon, le code est propre, facile à entretenir et lisible.

Poser cette question indique que vous pourriez être intéressé par les stratégies de gestion des erreurs. L'architecte de votre équipe doit décider de la façon de traiter les erreurs. Il y a plusieurs moyens de le faire:

1. permettre aux exceptions de se propager à travers - les attraper à la «boucle principale» ou dans une autre routine de gestion.

   • vérifier les conditions d'erreur et les gérer de manière appropriée

Bien sûr, jetez également un œil à la programmation orientée aspect - ils ont des façons intéressantes d'insérer if( o == null ) handleNull()dans votre bytecode.

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) {
    .....
    .....



    .....
}

N'utilisez jamais null. Ne le permettez pas.

Dans mes classes, la plupart des champs et des variables locales ont des valeurs par défaut non nulles, et j'ajoute des déclarations de contrat (assertions toujours actives) partout dans le code pour s'assurer que cela est appliqué (car c'est plus succinct et plus expressif que de le laisser) venir comme un NPE et ensuite avoir à résoudre le numéro de ligne, etc.).

Une fois que j'ai adopté cette pratique, j'ai remarqué que les problèmes semblaient se régler. Vous attraperiez les choses beaucoup plus tôt dans le processus de développement juste par accident et vous vous rendriez compte que vous aviez un point faible .. et plus important encore .. cela aide à résumer les préoccupations des différents modules, différents modules peuvent se `` faire confiance '' les uns les autres, et ne jonchent plus les code avecif = null else constructions!

Il s'agit d'une programmation défensive et se traduit par un code beaucoup plus propre à long terme. Nettoyez toujours les données, par exemple ici en appliquant des normes rigides, et les problèmes disparaissent.

class C {
    private final MyType mustBeSet;
    public C(MyType mything) {
       mustBeSet=Contract.notNull(mything);
    }
   private String name = "<unknown>";
   public void setName(String s) {
      name = Contract.notNull(s);
   }
}


class Contract {
    public static <T> T notNull(T t) { if (t == null) { throw new ContractException("argument must be non-null"); return t; }
}

Les contrats sont comme des mini-tests unitaires qui sont toujours en cours, même en production, et quand les choses échouent, vous savez pourquoi, plutôt qu'un NPE aléatoire, vous devez en quelque sorte comprendre.

Guava, une bibliothèque de base très utile de Google, possède une API agréable et utile pour éviter les null. Je trouve UsingAndAvoidingNullExplained 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 il ne peut rien contenir (auquel cas nous disons que la référence est "absente"). On ne dit jamais qu'il "contient null".

Usage:

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

Il s'agit d'un problème très courant pour tous les développeurs Java. Il existe donc un support officiel dans Java 8 pour résoudre ces problèmes sans code encombré.

Java 8 a introduit java.util.Optional<T>. Il s'agit d'un conteneur qui peut contenir ou non une valeur non nulle. Java 8 a donné un moyen plus sûr de gérer un objet dont la valeur peut être nulle dans certains cas. Il est inspiré des idées de Haskell et Scala .

En un mot, la classe Optional inclut des méthodes pour traiter explicitement les cas où une valeur est présente ou absente. Cependant, l'avantage par rapport aux références nulles est que la classe Facultatif <T> vous oblige à réfléchir au cas où la valeur n'est pas présente. Par conséquent, vous pouvez empêcher les exceptions de pointeur nul involontaires.

Dans l'exemple ci-dessus, nous avons une usine de service à domicile qui renvoie une poignée à plusieurs appareils disponibles dans la maison. Mais ces services peuvent être ou ne pas être disponibles / fonctionnels; cela signifie que cela peut entraîner une exception NullPointerException. Au lieu d'ajouter un nullif condition avant d'utiliser un service, encapsulons-la dans <Service> facultatif.

EMBALLAGE À L'OPTION <T>

Considérons une méthode pour obtenir une référence d'un service d'une usine. Au lieu de renvoyer la référence de service, enveloppez-la avec Facultatif. Il permet à l'utilisateur de l'API de savoir que le service retourné peut ou non être disponible / fonctionnel, utiliser de manière défensive

public Optional<Service> getRefrigertorControl() {
      Service s = new  RefrigeratorService();
       //...
      return Optional.ofNullable(s);
   }

Comme vous le voyez, Optional.ofNullable()fournit un moyen facile d'obtenir la référence encapsulée. Il existe un autre moyen d'obtenir la référence de Facultatif, soit Optional.empty()&Optional.of() . L'une pour renvoyer un objet vide au lieu de réaccorder null et l'autre pour encapsuler un objet non nullable, respectivement.

AINSI COMMENT EXACTEMENT IL AIDE À ÉVITER UN CHÈQUE NUL?

Une fois que vous avez encapsulé un objet de référence, Optional fournit de nombreuses méthodes utiles pour appeler des méthodes sur une référence encapsulée sans NPE.

Optional ref = homeServices.getRefrigertorControl();
ref.ifPresent(HomeServices::switchItOn);

Facultatif.ifPresent appelle le consommateur donné avec une référence s'il s'agit d'une valeur non nulle. Sinon, cela ne fait rien.

@FunctionalInterface
public interface Consumer<T>

Représente une opération qui accepte un seul argument d'entrée et ne renvoie aucun résultat. Contrairement à la plupart des autres interfaces fonctionnelles, Consumer devrait fonctionner via des effets secondaires. C'est tellement propre et facile à comprendre. Dans l'exemple de code ci-dessus,HomeService.switchOn(Service) obtient invoqué si la référence de détention facultative n'est pas nulle.

Nous utilisons l'opérateur ternaire très souvent pour vérifier la condition nulle et renvoyer une valeur alternative ou une valeur par défaut. Facultatif fournit une autre façon de gérer la même condition sans vérifier null. Optional.orElse (defaultObj) renvoie defaultObj si l'Optional a une valeur nulle. Utilisons ceci dans notre exemple de code:

public static Optional<HomeServices> get() {
    service = Optional.of(service.orElse(new HomeServices()));
    return service;
}

Maintenant, HomeServices.get () fait la même chose, mais d'une meilleure façon. Il vérifie si le service est déjà initialisé ou non. Si c'est le cas, renvoyez-le ou créez un nouveau nouveau service. <T> .orElse (T) facultatif permet de renvoyer une valeur par défaut.

Enfin, voici notre NPE ainsi que le code sans vérification nul:

import java.util.Optional;
public class HomeServices {
    private static final int NOW = 0;
    private static Optional<HomeServices> service;

public static Optional<HomeServices> get() {
    service = Optional.of(service.orElse(new HomeServices()));
    return service;
}

public Optional<Service> getRefrigertorControl() {
    Service s = new  RefrigeratorService();
    //...
    return Optional.ofNullable(s);
}

public static void main(String[] args) {
    /* Get Home Services handle */
    Optional<HomeServices> homeServices = HomeServices.get();
    if(homeServices != null) {
        Optional<Service> refrigertorControl = homeServices.get().getRefrigertorControl();
        refrigertorControl.ifPresent(HomeServices::switchItOn);
    }
}

public static void switchItOn(Service s){
         //...
    }
}

Le message complet est NPE ainsi que le code sans chèque Null… Vraiment? .

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

• Éviter les nuls avec la répartition polymorphe
• Éviter les nuls avec le style «Dites, ne demandez pas»

Dans les articles, il existe également un lien vers un référentiel Git pour un type Java peut-être que je trouve intéressant, mais je ne pense pas que cela puisse à lui seul diminuer le gonflement du code de vérification. Après avoir fait quelques recherches sur Internet, je pense que ! = Le gonflement du code nul pourrait être diminué principalement par une conception soignée.

J'ai essayé le NullObjectPatternmais pour moi ce n'est pas toujours la meilleure voie à suivre. Il y a parfois un "pas d'action" qui n'est pas approprié.

NullPointerExceptionest une exception Runtime qui signifie que c'est la faute des développeurs et avec suffisamment d'expérience, il vous indique exactement où est l'erreur.

Passons maintenant à la réponse:

Essayez de rendre tous vos attributs et ses accesseurs aussi privés que possible ou évitez de les exposer aux clients. Vous pouvez bien sûr avoir les valeurs d'argument dans le constructeur, mais en réduisant la portée, vous ne laissez pas la classe client passer une valeur non valide. Si vous devez modifier les valeurs, vous pouvez toujours en créer une nouvelle object. Vous ne vérifiez les valeurs dans le constructeur qu'une seule fois et dans les autres méthodes, vous pouvez être presque sûr que les valeurs ne sont pas nulles.

Bien sûr, l'expérience est la meilleure façon de comprendre et d'appliquer cette suggestion.

Octet!

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 pratique pour les longues chaînes de valeurs nulles 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 lever 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();

Puis-je y répondre de manière plus générale!

Nous rencontrons généralement ce problème lorsque les méthodes obtiennent les paramètres comme nous ne nous y attendions pas (un mauvais appel de méthode est la faute du programmeur). Par exemple: vous vous attendez à obtenir un objet, au lieu de cela, vous obtenez un null. Vous vous attendez à obtenir une chaîne avec au moins un caractère, au lieu de cela, vous obtenez une chaîne vide ...

Il n'y a donc pas de différence entre:

if(object == null){
   //you called my method badly!

}

ou

if(str.length() == 0){
   //you called my method badly again!
}

Ils veulent tous les deux s'assurer que nous avons reçu des paramètres valides, avant de faire d'autres fonctions.

Comme mentionné dans certaines autres réponses, pour éviter les problèmes ci-dessus, vous pouvez suivre le modèle de conception par contrat . Veuillez consulter http://en.wikipedia.org/wiki/Design_by_contract .

Pour implémenter ce modèle en java, vous pouvez utiliser des annotations java de base comme javax.annotation.NotNull ou utiliser des bibliothèques plus sophistiquées comme Hibernate Validator .

Juste un échantillon:

getCustomerAccounts(@NotEmpty String customerId,@Size(min = 1) String accountType)

Maintenant, vous pouvez développer en toute sécurité la fonction de base de votre méthode sans avoir à vérifier les paramètres d'entrée, ils protègent vos méthodes des paramètres inattendus.

Vous pouvez aller plus loin et vous assurer que seuls les pojos valides peuvent être créés dans votre application. (échantillon du site de validation d'hibernation)

public class Car {

   @NotNull
   private String manufacturer;

   @NotNull
   @Size(min = 2, max = 14)
   private String licensePlate;

   @Min(2)
   private int seatCount;

   // ...
}

J'ignore fortement les réponses qui suggèrent d'utiliser les objets nuls dans toutes les situations. Ce modèle peut rompre le contrat et enfouir les problèmes de plus en plus profonds au lieu de les résoudre, sans mentionner que l'utilisation inappropriée créera une autre pile de code passe-partout qui nécessitera une maintenance future.

En réalité, si quelque chose renvoyé par une méthode peut être nul et que le code appelant doit prendre une décision à ce sujet, il devrait y avoir un appel antérieur qui garantit l'état.

Gardez également à l'esprit que ce modèle d'objet nul sera gourmand en 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 d'utiliser ce modèle où le type est censé être une représentation de type primitif - comme des entités mathématiques, qui ne sont pas des scalaires: vecteurs, matrices, nombres complexes et objets POD (Plain Old Data), qui sont destinés à contenir l'état sous forme de types intégrés Java. Dans ce dernier cas, vous finirez par appeler des méthodes getter avec des résultats arbitraires. Par exemple, que doit renvoyer une méthode NullPerson.getName ()?

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

1. Ne jamais initialiser les variables à null.
2. Si (1) n'est pas possible, initialisez toutes les collections et tableaux pour vider les collections / tableaux.

Faire cela dans votre propre code et vous pouvez éviter les contrôles! = Null.

La plupart du temps, les contrôles nuls semblent protéger les boucles sur les collections ou les tableaux, alors initialisez-les simplement vides, vous n'aurez pas besoin de contrôles nuls.

// Bad
ArrayList<String> lemmings;
String[] names;

void checkLemmings() {
    if (lemmings != null) for(lemming: lemmings) {
        // do something
    }
}



// Good
ArrayList<String> lemmings = new ArrayList<String>();
String[] names = {};

void checkLemmings() {
    for(lemming: lemmings) {
        // do something
    }
}

Il y a une petite surcharge, mais cela en vaut la peine pour un code plus propre et moins d'exceptions NullPointerExceptions.

Il s'agit de l'erreur la plus courante 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;
}

public static <T> T ifNull(T toCheck, T ifNull) {
    if (toCheck == null) {
           return ifNull;
    }
    return toCheck;
}