Null Pointer Exceptions In Java - What EXACTLY They Are and How to Fix Them

Summary

In this Java tutorial, John, a lead Java software engineer, explains the common issue of NullPointerExceptions. He illustrates with examples how uninitialized or null-assigned variables can cause this exception. John advises using Java primitives over wrapper classes to avoid null values and suggests initializing variables properly. He also recommends returning empty collections instead of null to prevent NullPointerExceptions. For debugging, he highlights how Java 14's improved error messages can pinpoint the cause of the exception. Finally, John offers strategies for avoiding NullPointerExceptions, like null checks and proper initialization.

Takeaways

• 🐱 NullPointerException is one of the most common and troublesome exceptions in Java, often causing many bugs.
• 🔍 NullPointerException occurs when you try to use an object reference that is not pointing to any object (null).
• 🚫 Calling methods or accessing fields on a null object will result in a NullPointerException.
• 👨‍💻 Always initialize variables properly and avoid setting them to null unless necessary.
• 👀 Recent versions of Java (starting from Java 14) provide detailed error messages for NullPointerExceptions, making it easier to identify the cause.
• 🔒 Use primitive types (e.g., boolean) instead of their wrapper classes (e.g., Boolean) when possible, as they can't be set to null.
• 📋 When working with collections, initialize them to an empty list instead of null to avoid NullPointerExceptions during iterations.
• 🔄 Use null checks before performing operations on variables that might be null to prevent exceptions.
• 💡 For string comparisons, use `"literal".equals(variable)` instead of `variable.equals("literal")` to avoid null-related errors.
• 🛠 If you encounter a NullPointerException, either ensure the variable is properly initialized or use null checks to handle potential null values.

Q & A

What is a Null Pointer Exception in Java?

A Null Pointer Exception occurs when you try to call a method or access a field on an object reference that has been set to null, meaning it points to no object in memory.

Why is the Null Pointer Exception common in Java?

It's common because Java allows object references to be null, and developers might not always check for null before using these references, leading to attempts to perform operations on a non-existent object.

How can you cause a Null Pointer Exception with a Cat object in Java?

You can cause a Null Pointer Exception by setting a Cat object reference to null and then trying to call a method on it, like 'myCat.makeNoise()'.

What does 'null' signify in Java?

In Java, 'null' signifies the absence of an object reference, meaning the reference does not point to any object in memory.

How do you fix a Null Pointer Exception when it occurs?

To fix a Null Pointer Exception, you can either initialize the null variable with an actual object or add a null check before performing operations on the variable.

What is the benefit of using Java primitives over wrapper classes when dealing with null?

Java primitives like 'boolean' cannot be null, whereas wrapper classes like 'Boolean' can. Using primitives avoids the risk of Null Pointer Exceptions.

Why might initializing a collection to null cause a Null Pointer Exception?

Initializing a collection to null and then trying to iterate over it or access elements can cause a Null Pointer Exception because the collection itself is null and does not contain any elements.

How do recent versions of Java help when a Null Pointer Exception occurs?

Recent versions of Java provide more detailed error messages that specify which method or field access caused the exception, making it easier to identify and fix the problem.

What is a null check and why is it important?

A null check is a condition that verifies if an object reference is null before performing operations on it. It's important to prevent Null Pointer Exceptions when dealing with potentially null references.

What strategies can you use to avoid Null Pointer Exceptions in your Java code?

Avoid initializing variables to null, return empty collections instead of null from methods, and use primitive types over wrapper classes to reduce the likelihood of encountering null values.

How can you safely compare a string to a string literal in Java without causing a Null Pointer Exception?

You can safely compare a string to a string literal by using the string literal on the left side of the equals method, so if the string is null, the literal will not cause a Null Pointer Exception.

Outlines

00:00

🐾 Understanding Null Pointer Exceptions in Java

This paragraph introduces the concept of a Null Pointer Exception (NPE) in Java, which is a common source of bugs. The speaker, John, a lead Java software engineer, explains NPEs with an example involving a 'Cat' object. He demonstrates that when a variable like 'myCat' is set to null instead of referencing an actual object, attempting to call a method on it results in an NPE. The explanation includes the difference between a variable referencing an object and being null, which means it points to nothing. John also discusses other scenarios that can lead to NPEs, such as using a Boolean wrapper class set to null or trying to access elements from a null collection.

05:00

🔍 Diagnosing and Fixing Null Pointer Exceptions

In this section, the video script discusses how to address Null Pointer Exceptions once they occur. John explains that modern Java versions provide detailed error messages that can help pinpoint the exact cause of an NPE. He suggests two approaches to fixing NPEs: initializing the null variable with a value, or performing a null check before using the variable. The paragraph provides examples of both methods, emphasizing the importance of null checks in complex method chains and the use of empty collections instead of null to avoid exceptions.

10:03

🛠 Strategies to Prevent Null Pointer Exceptions

The final paragraph focuses on preventative measures to avoid Null Pointer Exceptions. John advises against initializing variables to null unless absolutely necessary and suggests returning empty collections instead of null from methods. He also provides a tip for string comparisons, recommending the reversal of the comparison to avoid NPEs when dealing with potentially null strings. The paragraph concludes with a call to action for viewers to like, subscribe, and check out a full Java course for more in-depth learning.

Keywords

💡Null Pointer Exception

A Null Pointer Exception occurs when a program attempts to use a reference that points to no location in memory (null). In the video, it is described as one of the most common exceptions in Java, often caused by trying to call methods or access fields on an object that has not been properly initialized. The presenter demonstrates this with the example of a 'Cat' object, where calling a method on a null reference leads to the error.

💡Reference

In Java, a reference points to the memory location where an object is stored. The video explains how a variable like 'myCat' is not the actual object but a reference to it. When this reference is null (i.e., it points to nothing), attempting to perform operations on it, such as calling methods, leads to a Null Pointer Exception.

💡Memory

Memory refers to the storage location where objects and variables are held during program execution. The video emphasizes that when a reference variable points to a valid memory location containing an object, operations like method calls can be performed. If a reference points to null, it means there's no object in memory to interact with, causing an exception.

💡Wrapper Class

A wrapper class in Java provides a way to use primitive data types (like int, boolean) as objects. In the video, the presenter discusses the 'Boolean' wrapper class (capital 'B'), which can be null, unlike the primitive 'boolean' (lowercase 'b'). This distinction is important as it can lead to a Null Pointer Exception when a null Boolean is used in conditional statements.

💡Primitive Type

Primitive types in Java are basic data types like int, boolean, and char, which cannot be null and always have a default value. The presenter contrasts primitive types with wrapper classes, explaining that using primitive booleans avoids the risk of a Null Pointer Exception, since they are never null.

💡Null Check

A null check is a programming practice where a variable is checked to see if it is null before performing operations on it. The video introduces null checks as a solution to avoid Null Pointer Exceptions. The presenter demonstrates how adding a condition like 'if (myCat != null)' prevents the program from calling methods on a null object.

💡Method Invocation

Method invocation refers to calling a method on an object in Java. The video highlights how invoking a method on a null reference (like 'myCat.makeNoise()' when 'myCat' is null) will lead to a Null Pointer Exception. Proper initialization or a null check is necessary before invoking methods to avoid this error.

💡Collection

A collection in Java is a data structure like a List, Set, or Map that holds multiple elements. The presenter uses the example of a list of 'favoriteCheeseburgers' to explain how iterating over a null collection can also cause a Null Pointer Exception. Best practice is to initialize collections as empty rather than null.

💡Empty List

An empty list is a collection that contains no elements but is still a valid object in memory. In the video, the presenter explains that it's safer to initialize a list as empty rather than null, because iterating over an empty list won't throw a Null Pointer Exception, while iterating over a null list will.

💡String Comparison

String comparison in Java is typically done using the '.equals()' method. The video covers how calling '.equals()' on a null string leads to a Null Pointer Exception. The presenter suggests flipping the comparison, using the string literal (which is never null) as the base, to avoid this error.

Highlights

Java's null pointer exception is one of the most common and problematic bugs.

A null pointer exception occurs when a variable set to null is used to call a method.

In Java, a variable is a reference to an object in memory, not the object itself.

Setting a variable to null means it points to nothing, causing a null pointer exception when a method is called on it.

Using Java's primitive types can prevent null pointer exceptions, as they cannot be set to null.

Java's wrapper classes, like Boolean, can be set to null and may cause null pointer exceptions.

Initializing collections to empty instances instead of null can prevent null pointer exceptions.

Java 14 and later provide detailed error messages for null pointer exceptions, aiding in debugging.

To fix a null pointer exception, ensure variables are initialized before use.

Performing null checks before method calls can prevent null pointer exceptions.

Avoid initializing variables to null unless absolutely necessary.

Returning empty collections instead of null from methods can prevent null pointer exceptions.

Flipping string comparisons can avoid null pointer exceptions when dealing with potentially null strings.

Always use null checks when dealing with external code where null values might be present.

The video provides a full Java course for further learning.

The video encourages viewers to subscribe for more Java tutorials.

Transcripts

if you've been coding in java for any

length of time you've definitely run

into the dreaded null pointer exception

it's one of the most common exceptions

and probably the biggest source of bugs

in all of java in this video we'll talk

about what exactly causes a null pointer

exception how to fix it when you

encounter one and strategies for

avoiding them in the first place my name

is john and i'm a lead java software

engineer i also have a full java course

available in a link down in the

description so go check it out first

what exactly causes a null pointer

exception let's talk about it with an

example let's say you're coding along

and at some point you decide you need a

new cat object so you go ahead and

create cat my cat equals new cat and

let's say you want to make that cat make

noise so you go ahead and call it's make

noise method with my cat dot make noise

and we can see that in that method it

just prints out meow so of course if we

go back here and run our program that's

exactly what it does it just prints out

meow but what if instead of

instantiating this my cat variable to a

new cat we instead set it to null let's

go ahead and run it and see what happens

and oh no we get the dreaded null

pointer exception now why exactly is

that sure we can see that we're setting

our mycat variable to null but what

exactly does null mean and why does our

code now result in a null pointer

exception to visualize it so what we

have in our code is a mycat variable

right that my cat variable isn't a cat

object itself but instead it's a

reference to a cat object in memory so

when we instantiate our mycat variable

to a new cat that means this my cat

variable is now a reference to an actual

cat object in memory so after that when

we call my cat dot make noise it has no

problem doing that at all our my cat

variable references an actual cat object

in memory and so we're able to tell this

cat object to make noise with no problem

but what happens if instead we set it to

null well instead of my cat pointing to

an actual cat object in memory it's

instead null which essentially means

it's pointing at nothing not even like

some empty box with no cat in it it's

pointing to nothing at all this is a

null pointer so when we call the make

noise method on our my cat variable that

has been set to null there's no cat to

make noise we have a mycat variable but

it's not pointing to any actual cat

object there's nothing to meow all we

have is a null pointer and so we get a

null pointer exception in our code most

of the time when we get a null pointer

exception this is the reason we have

some variable that's been set to null

and we try to call some method on it

more generally speaking just having some

variable set to null won't give you a

null pointer exception but you will get

a null pointer exception if you try to

do pretty much anything with a null

variable for example if you try to get

or set a field on that object like my

cat dot age equals three we get a null

pointer exception for essentially the

same reason there is no actual cat

object so we can't set its age to three

there are other things that can give you

a null pointer exception that you might

not expect for example what if we had a

boolean just called should print hello

and right now let's just initialize it

to true then we can have some if

statement so if should print hello then

we will print out hello so obviously if

we run that it will print out hello but

what will happen if instead of setting

this to true or false we initialize it

to null well as you may have guessed we

get a null pointer exception if you're

using a capital b boolean variable this

is the wrapper class for jabba's

lowercase b primitive boolean a

primitive boolean like all java

primitives can't be set to null as we

can see by the error we're getting here

but a capital b boolean the wrapper

class can be set to null and if you do

have a capital b boolean that is set to

null and you try to evaluate it in an if

statement it'll give you a null pointer

exception best practice in this

situation is to always use the java

primitive boolean whenever possible a

primitive boolean will never be null

it'll always be true or false another

way you might get an old pointer

exception that you may not expect is

let's say you have a collection like a

list of strings called like favorite

cheeseburgers and let's say you wanted

to use a for each loop to loop through

those cheeseburgers and just print them

all out so four string burger

in favorite cheeseburgers we're just

going to print out that burger what

happens is if this favorite

cheeseburgers list has been set to null

you get an old pointer exception so best

practice in these sorts of situations is

even if you have nothing to put in that

list instead of initializing it to null

you should just set it to be some empty

list so like new arraylist so when you

run this program with an empty list

instead of a null list which are two

very different things you don't get any

null pointer exception so all of that is

of course good to know right but what if

you're running into a null pointer

exception in your code right now how

should you go about fixing it well the

great news is with recent versions of

java starting with java 14 when you get

a null pointer exception the error

message that it prints out is enormously

helpful so if we go ahead and run this

our original code if we take a closer

look at this null pointer exception when

it's thrown it says cannot invoke cat

dot make noise because my cat is null

and it gives an exact line number in our

class in line 9. with earlier versions

of java all it would tell you is the

line number so you would basically just

see this part you'd see that there's a

null pointer exception and you could see

which line it was on but it wouldn't say

anything about which method it was

trying to call or which variable was

null that caused the problem now that

might be enough in a simple case like

this right where on line nine there's

only one thing that can be null that can

cause this problem it would have to be

when this my cat object is null and it

tries to call the make noise method on

it but there are plenty of other times

when just the line number wasn't enough

to know exactly what was going wrong for

example what if in our code we had

something like this if we got an error

and all it said was there was a null

pointer exception on line 36

we have no idea what's actually causing

the problem it could be that this cat's

variable is null and it gets a null

pointer exception when it tries to call

the get method on it or it could be that

this zeroth element in the cats list is

null and it gets a null pointer

exception when it tries to call the get

name method on it or it could be that

neither of these are null but instead

the name of that first cat in that list

is null and you get a null pointer

exception when you try to call the dot

length method on it but now with our

nice modern error messages we can scroll

over here and see okay cannot invoke

string.length because the return value

of cat.getname is null so once you know

what exactly is causing your

nullpointerexception how do you go about

fixing it you basically have two options

the first option is you can identify the

exact variable that's null that is

causing you problems and initialize it

with some value if the variable causing

your null pointer exception should never

be null this is what you'll need to do

so here i can look at the code that was

calling this method and see that okay

i'm creating this new cat object and i'm

adding it to my list but i never gave it

a name and that's why down here when

it's trying to get the name of that cat

object and then getting its length it's

causing a null pointer exception so just

back up here where i'm creating my cat

object i just need to set

the name on this my other cat so just my

other cat dot set name to jerry so now

when we run the program there are no no

pointer exceptions and it's correctly

printing out the length of the name that

we gave our cat and jerry has five

characters so it's printing out five but

what do you do if you don't have any

control over whether the variable that

you're working with is null or not or

maybe the variable being null is just a

valid situation that you have to deal

with the simplest way to fix it in that

situation is to just add a piece of code

that checks to see if that variable is

null and only performs the operation on

that variable if it's not null this is

commonly referred to just as a null

check so from our first example we know

that if this mycat variable is null if

we try to call the make noise method on

it we're going to get a null pointer

exception so what we can do is add just

a simple null check so we can say if my

cat is not equal to null

then we can call the make noise method

on it you'll see this kind of coding

pattern all over for the rest of your

java coding career it might seem overly

simplistic but there's really no need to

complicate things if a simple piece of

code like this will do the trick now if

you have a long chain of method calls

like this one and any one of these

values might be null you might need

multiple null checks which can get a

little bit nasty looking so to make sure

we can call this.length method at the

end first we need to make sure that this

getname method won't return null but to

make sure that we can even call this

getname method we have to make sure that

this get method won't return null and to

make sure that that won't cause a null

point or exception we first need to make

sure that cats is not null so that means

that we have to have a pretty large

series of null checks so we can say if

cats is not equal to null and

cats.get zero is not equal to null and

cats.get

zero

dot get name is not equal to null

then we know that we can successfully

return this value as the length of that

name otherwise maybe we'll just return

zero so this can definitely get kind of

ugly but sometimes you don't really have

a good way around it and the only way

you can make sure that you won't get a

null pointer exception is just having a

large series of null checks so now we

know how we can fix null pointer

exceptions when we get them but what are

some strategies for avoiding them in the

first place so in situations where you

have just a local variable like this

where you're declaring it and

instantiating it right in the same

method that you're using it you have

complete and full control in general

just try to avoid initializing variables

like that to null it's almost always

best to just initialize it properly

right there when you declare it there

are some very specific situations where

you might have to initialize a variable

to null just take very good care to make

sure that it is always getting

initialized to some actual object

somewhere down the line before you use

it also try to avoid returning null as

the return value in methods that you

write if at all possible for example if

you have some method that returns like a

collection right so this method here git

cats returns some list of cats so what

if at the end of this method ah you

don't have any cats that you want to

return you might think well it's a good

idea to just return null well that's

okay but then in whatever piece of code

that's calling this method it has to

deal with the possibility of the result

of this method being null what you can

do instead is just return an empty

collection so here we're using a list so

instead of returning null we can just

return a new arraylist as we saw earlier

an empty list won't give you any null

pointer exceptions when you try to loop

through it but a null list will another

small tip often you'll find yourself

having to do some string comparisons

where you need to take some string that

you have and compare it to some constant

value or some string literal for example

let's say we just wanted to take the

name of this my other cat object and we

wanted to see if it was equal to some

string literal which is just a string

that you write out literally in quotes

in the code like this so if we wanted to

see if this name was equal to newman so

we could write something like this so we

can say if

my other cat.getname

then we print out hello newman so this

code will work fine right but what will

happen if instead of setting the name to

jerry we have it set to null well if we

try and run that we're going to get a

null pointer exception and we can see

that it says we can't invoke string dot

equals because the return value of

cat.getname

is null so what's happening here is

get myothercat.getname is returning null

because that cat's name has been set to

null so when we try to call the dot

equals method on that null name we get a

null pointer exception so what you can

do instead to eliminate the possibility

of a null pointer exception in this

scenario is just flip this comparison

around so instead of saying my other cat

dot get name dot equals newman we can

say newman as a string literal in quotes

dot equals and pass in my other cat dot

get name so now when we run our code

just by flipping around that comparison

we no longer get a null pointer

exception this string literal newman is

of course not null we can see the string

value right there so there's no chance

of a null pointer exception when we call

dot equals on it and if this my other

cat dot get name does return null here

it doesn't cause any problems this

equals method just compares newman to

null and sees that they're not equal so

this equals method just ends up

returning false and everything just

works as it should with no exceptions

sometimes though you just don't have

complete control over the code that

you're having to deal with in those

cases it's best to just do a simple null

check before doing anything with that

variable if you enjoyed this video or

learned something please let me know by

leaving a like and be sure to subscribe

so you don't miss each new java tutorial

and be sure to check out the full java

course in the link down in the

description thank you so much for

watching i really do appreciate you

being here with me i'll see you next

time