Null Object Design Pattern Vs Null Object Verification

Question

Why a null object design pattern is better than checking a null object. If we look at the memory area in the design pattern of a null object, we will create a new dummy object of the same type. How, if we have an object of large size and a large number of objects with a zero value in the search query, this template will create so many null objects that will take up more memory than a simple check, which is for null that my cost ignores the performance delay.

Null Object Design Pattern

Answer 1

The whole problem with null is that if you try to access the null value, the application will throw a NullPointerException and abort.

To reduce the number of NullXXX classes in this null object design pattern (its actually just a factory dattern design, not the pattern itself), you can make a static final NullCustomer that always returns.

In Java 8, you can use the Optional method to indicate when a function does not always return values. This approach does not force you to create arbitrary null classes that pollute the general structure (you may also need to reorganize these null classes).

Eclipse and IntelliJ also offer to compile @Nullable , @NonNull time annotations, which provide compiler warnings when accessing potential null objects. However, many frameworks are not annotated. Therefore, IntelliJ is trying to detect these potential null hits with static analysis. In addition to the low acceptance of this approach, IntelliJ and Eclipse use their own annotations ( org.eclipse.jdt.annotation.NonNull , com.intellij.annotations.NotNull ), which are incompatible. But you can store annotations outside the code that work in IntelliJ. Eclipse wants to implement this in the future. The problem is that there are many frameworks that provide this feature , giving you many different annotations that do the same thing. There was a JSR-305 that is inactive. It will provide annotation in javax . I do not know why they did not push it further.

Answer 2

The main advantage of using a Null Object rather than null is that with null you need to repeat the checks to see if this object is really null , especially in all methods that require this object.

In Java 8, you will need to do:

 Object o = Objects.requireNotNull(o); //Throws NullPointerException if o is indeed null. 

So, if you have a method that constantly passes the same object to another method, each method will need to verify that the received object is not null before using it.

So, the best approach is to have a Null Object or Optional (Java 8 and above), so you don't have to do a null check all the time. Instead, one could:

 Object o = optional.get(); //Throws NullPointerException if internal value is indeed null. //Keep using o. 

No (valid) for null verification. The fact that you have Optional means that you can have a value or not.

Null Objects has no side effects because it usually does nothing (usually all methods are an empty method), so there is no need to worry about performance (bottlenecks / optimization, etc.).

Answer 3

The main difference (and probably advantage) of this template is a distinctive feature. Consider the following method definition:

 public static int length(String str); 

This method calculates the length of the given string. But can the argument be null ? What will this method do? Throw an exception? Return 0? Return -1? We do not know.

Some partial solution can be achieved by writing a good java document. The next and slightly better solution is the JSR305 annotattion @Nullable or @NotNullable , which the developer can ignore.

If you are using a Null object template (for example, optional from guava or java 8), your code looks like this:

 public static int length(Optional<String> str); 

Therefore, the developer must take care to bind his string to Optional, and therefore understands that this argument may be null. Trying to get a value from Optional, which contains an exception for exceptions, which does not always happen when working with regular null .

Obviously, you are right that using this template leads to some additional processor and memory consumption, which in most cases is not significant.

Answer 4

Suppose you have something like this:

 private SomeClass someField; void someMethod() { // some other code someField.method1(); // some other code someField.method2(); // some other code someField.method3(); } 

Now suppose that there are valid use cases where someField may be null and you do not want to call its methods, but you want to execute other sections of some other code method. You need to implement the method as follows:

 void someMethod() { // do something if (someField != null) { someField.method1(); } // do something if (someField != null) { someField.method2(); } // do something if (someField != null) { someField.method3(); } } 

Using a Null object with empty methods (no-op), we avoid code errors (and the ability to forget to add checks for all occurrences).

I often find this useful in situations where something is initialized asynchronously or optionally.