Daily #10: Quick Dive into Nullability Annotations in Java and Android

Hello! Today, I am going to talk about Nullability Annotations in Java and Android. These annotations - @NotNull, @Nonnull, @NotEmpty, @NotBlank, and @Nullable - are valuable tools to help us avoid unexpected null and empty values leading to runtime errors.

1. @NotNull and @Nonnull:

These annotations are similar; they declare that a variable, parameter, or method return value should never be null. @NotNull is from JetBrains' annotations library and is widely used in Android and Java development. @Nonnull is from the JSR-305 annotations library. Remember, these annotations themselves do not enforce the non-null behavior at runtime; they're primarily used for compile-time checks by static analysis tools.

Let's see them in action:

// Here, the parameter should never be null.

public void processString(@NotNull String str) {
    // processing of str
}

// The method should never return a null value.
@NotNull
public String provideString() {
    // provide a String
}

2. @NotEmpty and @NotBlank:

These annotations are used when a CharSequence, Collection, Map, or Array object should not be null and should not be empty. @NotBlank further demands that a CharSequence should not be all whitespace.

Let's look at an example:

// Here, the parameter should never be null or empty.
public void processString(@NotBlank String str) {
    // processing of str
}


// This method should never return a null or empty value.

@NotBlank
public String provideString() {
    // provide a String
}

Please note that these annotations inform developers about the intended behavior of variables, methods, and parameters, but they don't enforce these behaviors at runtime. For runtime enforcement, you would need to manually throw exceptions when these conditions are not met:

public void processString(@NotBlank String str) {
    if (str == null || str.trim().isEmpty()) {
        throw new IllegalArgumentException("processString() received a null or blank string");
    }
    // Continue processing str
}

3. @Nullable:

The @Nullable annotation indicates that a variable, parameter, or method return value can be null. This is a warning to developers to expect and handle null values appropriately.

// Here, the parameter can be null.
public void processString(@Nullable String str) {
    if (str == null) {
        // Handle null case here
    } else {
        // Continue processing str
    }
}


// This method can return a null value.

@Nullable

public String provideString() {
    // provide a String or null
}

Using these annotations makes your code more understandable and safer, preventing common runtime errors like NullPointerException and IllegalArgumentException.

In tomorrow's post, we'll discuss other annotation types and how they can enhance your code's robustness and readability. Stay tuned!