Java Tips In Addition To Best Practices To Avoid Nullpointerexception Inwards Coffee Applications

A NullPointerException inwards Java application is best means to solve it together with that is also key to write robust programs which tin give the sack function smoothly. As it said “prevention is meliorate than cure”, same is truthful amongst nasty NullPointerException. Thankfully past times applying unopen to defensive coding techniques together with next contract betwixt multiple purpose of application, you lot tin give the sack avoid NullPointerException inwards Java to a practiced extent. By the means this is the minute post service on NullPointerException inwards , In terminal post service nosotros receive got discussed nearly common exertion of NullPointerException inwards Java together with inwards this tutorial,  we volition acquire unopen to Java coding techniques together with best practices, which tin give the sack endure used to avoid NullPointerException inwards Java. Following these Java tips also minimize number of !=null check, which litter lot of Java code. As an sense Java programmer, you lot may endure aware of unopen to of these techniques together with already next it inwards your project, but for freshers together with intermediate developers, this tin give the sack endure practiced learning. By the way, if you lot know whatsoever other Java tips to avoid NullPointerException together with trim back zippo checks inwards Java, thus delight portion amongst us.

Java Tips together with Best practices to avoid NullPointerException 

These are uncomplicated techniques, which is real slow to follow, but has important comport on on code lineament together with robustness. In my experience, simply showtime tip is resulted inwards important improvement inwards code quality. As I said earlier, if you lot know whatsoever other Java tips or best practice, which tin give the sack assist to trim back zippo check, thus you lot tin give the sack portion amongst us past times commenting on this article.

1) Call equals() together with equalsIgnoreCase() method on known String literal rather unknown object

Always telephone band equals() method on known String which is non null. Since equals() method is symmetric, calling a.equals(b) is same equally calling b.equals(a), together with that’s why many programmer don’t pay attending on object a together with b. One side number of this telephone band tin give the sack termination inwards NullPointerException, if caller is null.

Object unknownObject = null;

//wrong means - may exertion NullPointerException

if(unknownObject.equals("knownObject")){

   System.err.println("This may termination inwards NullPointerException if unknownObject is null");

}

//right means - avoid NullPointerException fifty-fifty if unknownObject is null

if("knownObject".equals(unknownObject)){

    System.err.println("better coding avoided NullPointerException");

}

This is the most slow Java tip or best practise to avoid NullPointerException, but results inwards tremendous improvement, because of equals()being a mutual method.

2) Prefer valueOf() over toString() where both render same result

Since calling toString() on zippo object throws NullPointerException, if nosotros tin give the sack acquire same value past times calling valueOf() thus prefer that, equally passing zippo to  valueOf() returns "null", particularly inwards instance of wrapper classes  like Integer, Float, Double or BigDecimal.

BigDecimal bd = getPrice();

System.out.println(String.valueOf(bd)); //doesn’t throw NPE

System.out.println(bd.toString()); //throws "Exception inwards thread "main" java.lang.NullPointerException"

Follow this Java tips, if you lot are unsure nearly object beingness zippo or not.

3) Using zippo security methods together with libraries

There are lot of opened upwards root library out there, which does the heavy lifting of checking zippo for you. One of the most mutual ane is StringUtils from Apache commons. You tin give the sack usage StringUtils.isBlank(), isNumeric(), isWhiteSpace() together with other utility methods without worrying of  NullPointerException.

//StringUtils methods are zippo safe, they don't throw NullPointerException

System.out.println(StringUtils.isEmpty(null));

System.out.println(StringUtils.isBlank(null));

System.out.println(StringUtils.isNumeric(null));

System.out.println(StringUtils.isAllUpperCase(null));

Output:

true

true

false

false

But before reaching to whatsoever conclusion don't forget to read the documentation of Null security methods together with classes. This is unopen to other Java best practices, which doesn't require much effort, but termination inwards swell improvements.

4) Avoid returning zippo from method, instead render empty collection or empty array.

This Java best practise or tips is also mentioned past times Joshua Bloch inwards his book Effective Java which is unopen to other practiced root of meliorate programming inwards Java. By returning empty collection or empty array you lot brand certain that basic calls similar size(), length() doesn't neglect amongst NullPointerException. Collections class provides convenient empty List, Set together with Map equally Collections.EMPTY_LIST, Collections.EMPTY_SET together with Collections.EMPTY_MAP which tin give the sack endure used accordingly. Here is code example

public List getOrders(Customer customer){

   List termination = Collections.EMPTY_LIST;

   return result;

}

Similarly you lot tin give the sack usage Collections.EMPTY_SET together with Collections.EMPTY_MAP instead of returning null.

5)  Use of annotation @NotNull together with @Nullable

While writing method you lot tin give the sack define contracts nearly nullability, past times declaring whether a method is zippo security or not, past times using annotations similar @NotNull together with @Nullable. Modern days compiler, IDE or tool tin give the sack read this annotation together with assist you lot to seat a missing zippo check, or may inform you lot nearly an unnecessary zippo check, which is cluttering your code. IntelliJ IDE together with findbugs already supports such annotation. These annotations are also purpose of JSR 305, but fifty-fifty inwards the absence of whatsoever tool or IDE support, this  annotation itself function equally documentation. By looking @NotNull together with @Nullable, programmer tin give the sack himself make upwards one's hear whether to banking concern check for zippo or not. By the means ,this is relatively novel best practise for Java programmers together with it volition bring unopen to fourth dimension to acquire adopted.

6)  Avoid unnecessary autoboxing together with unboxing inwards your code

Despite of other disadvantages similar creating temporary object, autoboxing are also prone to NullPointerException, if the wrapper class object is null. For example,  following code volition neglect amongst NullPointerException if someone doesn't receive got telephone number together with instead render null.

Person ram = new Person("ram");

int telephone = ram.getPhone();

Not simply equality but < , > tin give the sack also throw NullPointerException if used along autoboxing together with unboxing. See this article to acquire more pitfalls of autoboxing together with unboxing inwards Java.

7) Follow Contract together with define reasonable default value

One of the best means to avoid NullPointerException inwards Java is equally uncomplicated equally defining contracts together with next them. Most of the NullPointerException occurs because Object is created amongst incomplete information or all required dependency is non provided. If you lot don't allow to make incomplete object together with gracefully deny whatsoever such asking you lot tin give the sack forestall lots of NullPointerException downwardly the road. Similarly if  Object is allowed to endure created, than you lot should function amongst reasonable default value. for instance an Employee object tin give the sack non endure created without id together with name, but tin give the sack receive got an optional telephone number. Now if Employee doesn't receive got telephone number than instead of returning null, render default value e.g. zero, but that selection has to endure carefully taken sometime checking for zippo is slow rather than calling an invalid number. One same note, past times defining what tin give the sack endure zippo together with what tin give the sack non endure null, caller tin give the sack brand an informed decision. Choice of failing fast or accepting zippo is also an of import pattern determination you lot bespeak to bring together with adhere consistently.

8)  If you lot are using database for storing your domain object such equally Customers, Orders etc than you lot should define your null-ability constraints on database itself. Since database tin give the sack acquire information from multiple sources, having null-ability banking concern check inwards DB volition ensure information integrity. Maintaining zippo constraints on database volition also assist inwards reducing null banking concern check inwards Java code. While loading objects from database you lot volition endure sure, which plain tin give the sack endure zippo together with which plain is non null, this volition minimize unnecessary != null banking concern check inwards code.

9) Use Null Object Pattern

This is unopen to other means of avoiding NullPointerExcpetion inwards Java. If a method returns an object, on which caller, perform unopen to operations e.g. Collection.iterator() method returns Iterator, on which caller performs traversal. Suppose if a caller doesn’t receive got whatsoever Iterator, it tin give the sack render Null object instead of null. Null object is a exceptional object, which has unlike pregnant inwards unlike context, for example, hither an empty Iterator, calling hasNext() on which returns false, tin give the sack endure a zippo object. Similarly inwards instance of method, which returns Container or Collection types, empty object should endure used instead of returning null. I am planning to write a divide article on Null Object pattern, where I volition portion few to a greater extent than examples of NULL objects inwards Java.

That’s all guys, these are yoke of slow to follow Java tips together with best practices to avoid NullPointerException. You would appreciate, how useful these tips tin give the sack be, without also much of effort. If you lot are using whatsoever other tip to avoid this exception, which is non included inwards this list, than delight portion amongst us via comment, together with I volition include them here.

Further Learning
Complete Java Masterclass
Java Fundamentals: The Java Language
Java In-Depth: Become a Complete Java Engineer!

Sumber https://javarevisited.blogspot.com/

Share this post