How to Fix a NullPointerException in Your Java Homework

You ran your Java homework, and instead of the output you wanted, the console turned red and printed NullPointerException. If you have no idea what that means or where it came from, take a breath. This is the most common error in Java, every student hits it, and it is usually a five-minute fix once you know how to read it.

This guide is written for students by our experts and It explains what a NullPointerException really is in plain English, shows you how to find the exact line that broke, and walks through the three situations where homework assignments trigger it most. Every code example here was tested and runs on a real Java machine, so you can copy it, see the error yourself, and then see the fix.

What Is a NullPointerException in Java?

In Java, an object variable does not hold the object itself. It holds a reference, which is like an address that points to where the object lives in memory. When a variable does not point to any object yet, its value is null, which means "points to nothing."

A NullPointerException (often shortened to NPE) happens when your code tries to use a variable as if it holds an object, but the variable is actually null. You cannot call a method on nothing, and you cannot read a field from nothing, so Java stops and throws the error.

Here is the simplest example that causes it:

public class Example {
    public static void main(String[] args) {
        String message = null;        // points to nothing
        System.out.println(message.length());   // tries to use nothing
    }
}

Calling .length() on a null string is the problem. There is no object there to measure, so Java throws a NullPointerException. Almost every NPE in your homework is a version of this same situation: you used something before it actually existed.

How to Read the Error and Find the Exact Line

This is the skill that saves you. Most students panic at the red text and start changing random lines. Do not do that. The error message tells you exactly where the problem is, if you know how to read it. Newer versions of Java (14 and above, which almost every school now uses) even tell you the exact variable that was null.

Look at a real error message from one of the examples later in this guide:

Read it in three parts:

• What went wrong: Cannot invoke "Student.getName()" because "found" is null. Java is telling you that it tried to run getName() on a variable called found, but found was null. That names your culprit directly.
• Where it happened: at StudentLookup.main(StudentLookup.java:25). The problem is in the file StudentLookup.java, on line 25. Go straight to that line.
• The path it took: If there are more at lines below, they show the chain of methods that led there, from newest at the top to oldest at the bottom. The top line is almost always the one you care about.

So before you change anything, read the message, find the variable name, and jump to that line number. This one habit turns a scary error into a simple to-do.

Let Java Tell You Exactly What Is Null

Here is a tip most guides skip, and it is a real time saver. Since Java 14, the error message includes "helpful NullPointerException messages" that name the exact thing that was null, like because "found" is null or because "students[0]" is null. This feature is turned on by default in modern Java, so if you are using a recent version in NetBeans, Eclipse, IntelliJ, or VS Code, you already have it.

If your message only says java.lang.NullPointerException with no explanation, you are probably on an old Java version, or your program was compiled without debug details. Updating to a current Java version, which your school likely already provides, gives you these clearer messages for free. Reading them is the fastest way to fix the error, because Java is literally naming the variable you need to look at.

Scenario 1: You Forgot to Create the Object With new

This is the number one cause for beginners. You declared an object or a list, but you never actually built it with new. In Java, an object field that is never assigned starts out as null.

Imagine a homework task where you keep a list of student names. Here is code that looks right but crashes:

import java.util.ArrayList;

public class ClassRoster {
    private ArrayList<String> students;   // declared, but never created with new

    public void addStudent(String name) {
        students.add(name);   // students is still null here
    }

    public static void main(String[] args) {
        ClassRoster roster = new ClassRoster();
        roster.addStudent("Maya");
    }
}

The message names this.students as the null value, and points to line 7. The students list was declared but never built, so it is null, and calling .add() on it fails.

The fix: Create the list with new when you declare it.

private ArrayList<String> students = new ArrayList<>();   // now it really exists

After that change, students.add(name) works because there is a real list to add to. The rule to remember: declaring a variable is not the same as creating the object. You almost always need new before you use it.

Scenario 2: Your Array of Objects Is Full of Nulls

This one traps students constantly, because the code looks finished. When you create an array of objects, Java builds the array, but every slot inside starts as null until you fill it. The array exists, but the objects inside do not exist yet.

class Student {
    String name;
    Student(String name) {
        this.name = name;
    }
    String getName() {
        return name;
    }
}

public class Classroom {
    public static void main(String[] args) {
        Student[] students = new Student[3];   // array exists, but all 3 slots are null
        System.out.println(students[0].getName());   // students[0] is null
    }
}

Notice how clear the message is. It says students[0] is null. The array has three empty slots, and you tried to use the first one before putting a Student in it.

The fix: Put a real object in each slot before you use it.

Student[] students = new Student[3];
students[0] = new Student("Maya");   // fill each slot first
students[1] = new Student("Leo");
students[2] = new Student("Sara");

for (Student s : students) {
    System.out.println(s.getName());   // now every slot has a real Student
}

This prints the three names with no error. The lesson: new Student[3] makes room for three students, but it does not make the students. You have to create each one.

Scenario 3: A Method Returned null and Your Code Used It

This scenario is sneaky, and it is the one that often makes your JUnit test cases fail in a homework autograder. A method searches for something, does not find it, and returns null. Your code then uses that result without checking, and it crashes only when the item is missing.

class Student {
    String name;
    Student(String name) { this.name = name; }
    String getName() { return name; }
}

class StudentDatabase {
    Student[] roster = { new Student("Maya"), new Student("Leo") };

    // Returns null when no student matches. This is the hidden trap.
    Student findByName(String target) {
        for (Student s : roster) {
            if (s.getName().equals(target)) {
                return s;
            }
        }
        return null;   // nothing found
    }
}

public class StudentLookup {
    public static void main(String[] args) {
        StudentDatabase db = new StudentDatabase();
        Student found = db.findByName("Zoe");   // Zoe is not in the roster
        System.out.println("Found: " + found.getName());   // found is null
    }
}

The search for "Zoe" found nothing, so findByName returned null, and found became null. Then found.getName() failed. This is exactly the kind of case a grader tests on purpose, by searching for something that is not there.

The fix: Check the result for null before you use it.

Student found = db.findByName("Zoe");

if (found != null) {
    System.out.println("Found: " + found.getName());
} else {
    System.out.println("No student named Zoe was found.");
}

Now the program handles the missing case calmly instead of crashing. Any time a method can return null, treat that result as "maybe empty" and check it before you use it.

How to Avoid NullPointerException in Your Homework

Fixing the error is good. Writing code that never throws it is better, and it earns cleaner marks. Here are the habits that prevent most NPEs in student assignments.

• Initialize objects when you declare them: If you know a list or object will be used, build it with new right away, so it is never left as null.
• Check for null before you use a result: This is the most common way to handle a null pointer exception in Java. A simple guard stops the crash:
  GuardCheck.java Copy

  if (name != null) {
      System.out.println(name.length());
  }

• Use a try-catch block when you cannot control the input: If a value might be null and you want your program to keep running, you can catch the error:
  TryCatchCheck.java Copy

  try {
      System.out.println(name.length());
  } catch (NullPointerException e) {
      System.out.println("The name was missing.");
  }

  Use this carefully. For homework, fixing the real cause is usually better than catching the error, but a try-catch is fine when the assignment expects your program to survive bad input.
• Return safe values instead of null: If you write a method, try to return an empty string or an empty list instead of null, so the code that calls it never has to worry.
• Use Optional to avoid null pointer exception in Java: Optional is a modern Java tool that clearly says "this might be empty" and forces you to handle that case, so you never accidentally use a null.
  OptionalDemo.java Copy

  import java.util.Optional;
  
  public class OptionalDemo {
      static Optional<String> findNickname(String name) {
          if (name.equals("Maya")) {
              return Optional.of("May");
          }
          return Optional.empty();   // empty, but never null
      }
  
      public static void main(String[] args) {
          String nick = findNickname("Zoe").orElse("No nickname");
          System.out.println(nick);   // prints: No nickname
      }
  }

  Because findNickname returns an Optional, the caller uses .orElse(...) to supply a backup value, and a NullPointerException simply cannot happen there.

A Quick Checklist Before You Submit

Run through this list and you will catch almost every null pointer exception before your grader does.

• Did you create every object and list with new before using it?
• If you made an array of objects, did you fill each slot before reading it?
• For every method that can return null, did you check the result before using it?
• Did you read the error message and go to the exact line number it named?
• Did you test your program with missing or empty input, not just the perfect input?