Comment éviter l'avertissement null en utilisant @NotNull et en vérifiant null dans une autre méthode avant l'appel de méthode?

Question

J'ai un peu d'un système de validation complexe, que simplifié ressemble à quelque chose comme ce qui suit:

private static void mainMethod(@Nullable String startParam, @Nullable String nextParam) { 

    String nextStep = methodSelect(startParam, nextParam); 

    switch (nextStep) { 
     case "none": 
      break; 
     case "goFinal": 
      finalMethod(startParam); 
      break; 
     case "goNext": 
      nextMethod(nextParam); 
      break; 
    } 
} 

private static void nextMethod(@NotNull String nextParam) { 
    System.out.println(nextParam); 
} 

private static void finalMethod(@NotNull String startParam) { 
    System.out.println(startParam); 
} 

@NotNull 
private static String methodSelect(@Nullable String startParam,@Nullable String nextParam) { 
    if (startParam == null && nextParam == null) { 
     return "none"; 
    } if (startParam == null) { 
     return "goNext"; 
    } else { 
     return "goFinal"; 
    } 
} 

Mais je reçois des avertissements lorsque dans l'instruction switch appelant les deux finalMethod() et nextMethod() sur « Argument x pourrait be null ", même si methodSelect() et l'instruction switch vérifient ensuite que ces arguments ne seront pas NULL. Comment est-ce que je peux me débarrasser correctement de ces avertissements, heureusement sans avoir une autre vérification de null dans ou avant ces méthodes? Merci!

J'utilise IntelliJ IDEA 04/03/2016, Java 8 et annotations:

import org.jetbrains.annotations.NotNull; 
import org.jetbrains.annotations.Nullable; 

Answer 1

C'est un code très délicat - vous mimer la réflexion pour faire un appel à différentes méthodes en fonction de l'exécution tests.

Dans IntelliJ IDEA, vous souhaitez supprimer l'avertissement dans le IDE ou via un code annotation.

Certains autres outils ont une analyse de code plus sophistiquée. Voici une légère variante de votre code qui utilise un booléen au lieu d'une chaîne pour indiquer quelle méthode appeler. Le Nullness Checker du Checker Framework est capable de vérifier la nullité-sécurité de ce code, grâce à l'annotation postcondition @EnsuresNonNullIf.

import org.checkerframework.checker.nullness.qual.*; 

class Example { 

    private static void mainMethod(@Nullable String startParam, @Nullable String nextParam) { 

    if (! useFinal(startParam)) { 
     // do nothing 
    } else { 
     finalMethod(startParam); 
    } 
    } 

    private static void nextMethod(@NonNull String nextParam) { 
    System.out.println(nextParam); 
    } 

    private static void finalMethod(@NonNull String startParam) { 
    System.out.println(startParam); 
    } 

    @EnsuresNonNullIf(expression="#1", result=true) 
    private static boolean useFinal(@Nullable String startParam) { 
    if (startParam == null) { 
     return false; 
    } else { 
     return true; 
    } 
    } 

} 

L'annotation @EnsuresNonNullIf ne gère pas actuellement Strings utilisé dans votre code d'origine; vous pouvez demander une telle extension aux mainteneurs ou l'implémenter vous-même et soumettre une demande d'extraction.