Quali sono gli usi corretti di @NonNull e @Nullable?

Question

Sono confuso sull'uso corretto di queste annotazioni.

android.support.annotation.NonNull; 
android.support.annotation.Nullable; 

Le informazioni contenute nella documentazione per @NonNull dice:

Indica che un parametro, il campo o il valore di ritorno del metodo non può mai essere nullo.

Cosa significa nel caso di parametri, quando non c'è nulla che impedisca di passare null?

Ad esempio, supponiamo di avere una classe MyObject e che un'istanza possa o meno avere un titolo.

public final class MyObject { 

    private String title = null; 

    public void setTitle(String title) { 
     if (title == null) 
      throw new NullPointerException(); 
     this.title = title; 
    } 

    public void clearTitle() { 
     title = null; 
    } 
} 

Qui sto usando null per rappresentare l'assenza di un titolo, ma questo è un dettaglio di implementazione, quindi non vorrebbe un unico metodo di fissazione e di compensazione il titolo.

Se io marco il campo title come @Nullable, Android Studio mi dice che il parametro da setTitle dovrebbe probabilmente essere contrassegnato @Nullable troppo (ma questo è il contrario di quello che voglio).

Se io marco il parametro al metodo setTitle come @NonNull Ho ricevuto un avviso che la condizione è sempre title == nullfalse.

Qual è l'uso corretto di queste annotazioni in un caso come questo? Se @NonNull significa che un parametro può essere non è mai null è errato utilizzarlo per indicare non deve essere null? Se sì, c'è un modo corretto per indicarlo?

Answer 1

Il punto è che questa annotazione è una sorta di contratto, quindi non è necessario effettuare controlli se si annotare correttamente i metodi. Android Studio controllerà che tu non abbia problemi con esso. Puoi ancora ignorarlo, ma ciò provocherà avvisi del compilatore.

Se si omettono i controlli di sicurezza inutili (per contratto), verranno correttamente generate le eccezioni nulle. Ma lo sviluppatore è stato avvisato con la tua annotazione.

Answer 2

@Nonnull e @Nullable sono dichiarativi. Questo è un suggerimento per i colleghi sviluppatori di software. Dite loro che un parametro può essere un valore nullo o che non lo deve.

Se si contrassegna un parametro con il @Nonnull annotazione, dire ogni persona che utilizza l'API che non dovrebbero passare un valore nullo qui, altrimenti hanno a che fare con le conseguenze (ad esempio NullPointerException).

Puoi usarlo per dichiarare, il parametro DOVREBBE non essere nullo, questo è un caso d'uso valido, secondo me.

Answer 3

Proseguire e contrassegnare il parametro sul metodo setTitle come @NonNull.

In questo modo il compilatore genera un errore quando alcune chiamate di codice setTitle con un valore che possono essere nulle. Quindi il compilatore assicura che setTitle è mai chiamato con null. Pertanto è possibile rimuovere il controllo null nel metodo, rendendo l'avviso 'title == null is always false'.

I.e. il codice sarà simile a questa:

public final class MyObject { 

    private String title = null; 

    public void setTitle(@NonNull String title) { 
     this.title = title; 
    } 

    public void clearTitle() { 
     title = null; 
    } 
} 

(Nota: non sto usando Android Studio, ma credo che si comporta in modo simile a Eclipse In Eclipse ottengo un errore Null type mismatch: required '@NonNull String' but the provided value is null(/inferred as @Nullable) quando si cerca di passare espressioni nulli o che possono essere nulli. a setTitle)

BTW:. anche annotare la definizione di campo title con @Nullable renderà più esplicito title può anche contenere null valori.

Answer 4

Se si contrassegna l'argomento @NonNull, l'utente del metodo deve eseguire il controllo Null, poiché @NonNull non acquisirà NPE in fase di esecuzione. Quindi, per esempio, se avessi una classe di utilità con metodi helper che verifica la presenza di null prima dell'esecuzione, contrassegni tali argomenti come @Nullable poiché tecnicamente puoi passare un valore nullo, ma lo stai verificando in sicurezza.