Using @Nullable in Java

Question

I have a question regarding the usage of @Nullable annotation in Java.

From what I've read, it's a good practice to set in on methods that may return a null value. In this way, the IDE may help detect some null pointer exception errors or suggest the removal unnecessary null pointer exception checks if @NotNull is used.

So far so good, but what about using @Nullable for method parameters? Is this a good practice or will the code become even more verbose (if used with final) and the benefit may be missing since you don't always know what arguments will be passed to the function call? Also, what is your opinion on using @Nullable with setter methods?

The usage is related to a situation when working in a company and not to a small project (like a homework).

Possible duplicate of [nullable annotation usage](http://stackoverflow.com/questions/14076296/nullable-annotation-usage) — ifloop, Apr 10 '14 at 12:37
I think, just like premature optimisation, there is a good case against stuffing your code full of annotations that solve problems you don't really have. (At the price of radically reducing readability.) But this is just my personal opinion, not a definitive answer. — biziclop, Apr 10 '14 at 12:38
@ifLoop It's definitely not a duplicate: the other question asks how it works, this one asks when it is wise or helpful to use it. — biziclop, Apr 10 '14 at 12:39

score 7 · Answer 1 · edited May 23 '17 at 10:34

7

For own, little projects one doesn't have to use this. But when creating libraries for others, this may help your API users to write robust applications. IMO

As I posted in the comment: See nullable annotation usage for a good answer to that particular question.

edited May 23 '17 at 10:34

Community

1
1

answered Apr 10 '14 at 12:40

ifloop

8,079
2
26
35

score 7 · Accepted Answer · edited May 23 '17 at 10:34

Due to the inherent complexity, flow analysis is best performed in small chunks. Analyzing one method at a time can be done with good tool performance - whereas whole-system analysis is out of scope for the Eclipse Java compiler. The advantage is: analysis is fast and can be done incrementally such that the compiler can warn you directly as you type. The down-side: the analysis can not "see" which values (null or non-null) are flowing between methods (as parameters and return values).

This is where null annotations come into play. By specifying a method parameter as @NonNull you can tell the compiler that you don't want a null value in this position.

Reference

Reference 2

Usage: This link explains what annotation to use where.

Usage 2

Getters/Setters: Yes, it is possible. The Project Lombok (http://projectlombok.org/index.html) defines annotations for generating getters/setters and more.

So for example
@lombok.Data;
public class Person {
   private final String name;
   private int age;
}
Will generate getter for name (not setter since it is final) and getter/setter for age. It will also generate equals, hashCode, toString and construtor initializing required fields (name). Adding @AllArgsConstructor would generate constructor initializing both fields.

There are other annotations and parameters giving you control over access rights (should your getter be protected or public), names (getName or name?), etc. And there is more. For example, I really like the extension methods.

Lombok is very easy to use. Just download the jar and use the annotations, then the getter/setters can be used in your code without actually being spelled out. Moreover, IDE's like Netbeans support this, so that you see the getter/setter in code completion, navigation, etc. The annotations are used only during compilation not during runtime, so you don't distribute lombok with your jar's.

NotNull: This is supported by findbugs and IdeaJ IDE, maybe others

Reference 3

Thank you for your answer. What do you think about using it on setter methods? — Slimu, Apr 10 '14 at 12:50

score 3 · Answer 3 · answered Apr 10 '14 at 12:57

The usage of @Nullable is to let a user and the compiler know it is fine to allow a null value in as that parameter.

I believe it is a more straight-forward way of letting a user looking at your API to know that passing null will not create a NPE or undefined behavior.

For setter, if that field is going to be used in many places, it would be nice to look at it's setter and discover null is handled.

That being said I think it should only be used for API's or libraries, using them in your own code would create too much useless code.

Using @Nullable in Java

3 Answers3