How to Debug Java Code (2026): A Step-by-Step Guide for Freshers

Oct 29, 2026

How do you debug Java code? Follow six steps: (1) reproduce the problem, (2) read the error message and stack trace from top to bottom, (3) find the first line of your own code in the trace, (4) form a guess about the cause, (5) test the guess with a breakpoint, a log line or a small experiment, and (6) fix it, then re-test. Don’t change code at random. Debugging is a method, not luck, and it is one of the most valuable skills a fresher can show in an interview and on the job.

This guide from VibrantMinds Technologies in Pune teaches how to debug Java code with real examples. You’ll learn to read a Java stack trace, fix common exceptions such as NullPointerException, use breakpoints in IntelliJ IDEA, debug Spring Boot applications, add useful logging and answer Java debugging interview questions. It is written for anyone searching how to debug Java code, Java debugging for beginners, how to read a Java stack trace, NullPointerException in Java how to fix, IntelliJ debugger tutorial for beginners, common Java exceptions and solutions, Spring Boot debugging tips, Java debugging interview questions, debugging skills for freshers or a free IT job WhatsApp group for Java freshers in Pune.

Takeaway	Detail
Debugging is a method	Reproduce, read, locate, hypothesise, test, fix, re-test.
Read the stack trace carefully	It tells you the exception, the message and where it happened.
Find your own code first	Look for the first line that belongs to your package.
Use the debugger, not only `System.out.println`	Breakpoints let you inspect real values at runtime.
Change one thing at a time	Random edits make bugs harder to find.
Write a small test that fails	Then fix the bug and watch it pass.
Say your debugging steps in interviews	It shows maturity, not weakness.

WHY DEBUGGING MATTERS FOR FRESHERS

Most of a developer’s day is reading, understanding and fixing code, not writing new code. Interviewers and teams notice freshers who can:

Read an error calmly instead of panicking
Find the cause instead of guessing
Explain what they checked and why
Fix the bug and prevent it from returning

If you can describe how you debugged a real problem in your project, you stand out from candidates who only describe features.

THE 6-STEP DEBUGGING METHOD

Golden rule: change one thing at a time and re-run. If you change five things and the bug disappears, you won’t know which change fixed it.

HOW TO READ A JAVA STACK TRACE

A stack trace is a map of what the program was doing when the error occurred.

How to read it

Part	Meaning	Here
Exception type	What kind of error	`NullPointerException`
Message	Details about the cause	`"name" is null`
First `at` line	Where it happened	`StudentService.printLength`, line 18
Next lines	The chain of calls that led there	controller, then `main`
Your package	Lines starting with your package name	`com.example.demo...`

Steps

Read the exception type and message first.
Find the first line in your own package. That’s usually where to look.
Open that file and line, and check what values are involved.
Walk up the call chain to see who passed the bad value.

“Caused by” chains

In long traces, the last “Caused by” is often the root cause. Scroll down to it, and don’t stop at the first line.

Tip: copy the exact error message into your notes. Searching the exact message (without your own class names) often leads to the explanation.

THE 10 MOST COMMON JAVA EXCEPTIONS AND HOW TO FIX THEM

#	Exception	Typical cause	How to fix
1	`NullPointerException`	Using a reference that is `null`	Check for null, initialise the object, trace where it should have been set
2	`ArrayIndexOutOfBoundsException`	Index outside 0 to length-1	Check loop limits (`i < arr.length`)
3	`IndexOutOfBoundsException` (lists)	`list.get(5)` on a smaller list	Check `list.size()` first
4	`ClassCastException`	Casting to an incompatible type	Use `instanceof` or correct generics
5	`NumberFormatException`	`Integer.parseInt("abc")`	Validate input, catch the exception
6	`ArithmeticException`	Division by zero	Check the divisor
7	`ConcurrentModificationException`	Changing a collection while looping	Use an `Iterator` or `removeIf`
8	`StackOverflowError`	Infinite recursion	Add or fix the base case
9	`OutOfMemoryError`	Too much data held in memory	Remove memory leaks, process data in chunks
10	`FileNotFoundException`	Wrong path or missing file	Check the path and working directory

Example: fixing a NullPointerException

java

// Buggy
String name = getStudentName(101);       // returns null if not found
System.out.println(name.length());       // NullPointerException

// Fixed: handle the null case explicitly
String name = getStudentName(101);
if (name != null) {
    System.out.println(name.length());
} else {
    System.out.println("Student not found");
}

// Or use Optional
Optional<String> opt = Optional.ofNullable(getStudentName(101));
System.out.println(opt.map(String::length).orElse(0));

// Buggy
String name = getStudentName(101);       // returns null if not found
System.out.println(name.length());       // NullPointerException

// Fixed: handle the null case explicitly
String name = getStudentName(101);
if (name != null) {
    System.out.println(name.length());
} else {
    System.out.println("Student not found");
}

// Or use Optional
Optional<String> opt = Optional.ofNullable(getStudentName(101));
System.out.println(opt.map(String::length).orElse(0));

// Buggy
String name = getStudentName(101);       // returns null if not found
System.out.println(name.length());       // NullPointerException

// Fixed: handle the null case explicitly
String name = getStudentName(101);
if (name != null) {
    System.out.println(name.length());
} else {
    System.out.println("Student not found");
}

// Or use Optional
Optional<String> opt = Optional.ofNullable(getStudentName(101));
System.out.println(opt.map(String::length).orElse(0));

Example: fixing a ConcurrentModificationException

java

// Buggy
for (String s : list) {
    if (s.startsWith("A")) list.remove(s);   // ConcurrentModificationException
}

// Fixed
list.removeIf(s -> s.startsWith("A"));

// Buggy
for (String s : list) {
    if (s.startsWith("A")) list.remove(s);   // ConcurrentModificationException
}

// Fixed
list.removeIf(s -> s.startsWith("A"));

// Buggy
for (String s : list) {
    if (s.startsWith("A")) list.remove(s);   // ConcurrentModificationException
}

// Fixed
list.removeIf(s -> s.startsWith("A"));

Example: fixing a StackOverflowError

java

// Buggy: no base case
int factorial(int n) { return n * factorial(n - 1); }

// Fixed
int factorial(int n) {
    if (n <= 1) return 1;     // base case
    return n * factorial(n - 1);
}

// Buggy: no base case
int factorial(int n) { return n * factorial(n - 1); }

// Fixed
int factorial(int n) {
    if (n <= 1) return 1;     // base case
    return n * factorial(n - 1);
}

// Buggy: no base case
int factorial(int n) { return n * factorial(n - 1); }

// Fixed
int factorial(int n) {
    if (n <= 1) return 1;     // base case
    return n * factorial(n - 1);
}

COMPILE ERRORS VS RUNTIME ERRORS VS LOGIC ERRORS

Type	When it appears	Example	How you find it
Compile-time error	Before running	Missing semicolon, type mismatch, undefined variable	The IDE underlines it and the compiler reports it
Runtime error (exception)	While running	`NullPointerException`, `ArithmeticException`	Stack trace
Logic error	Runs without crashing but gives the wrong result	Using `<` instead of `<=`	Debugger, tests, careful reading

Logic errors are the hardest because there’s no error message. This is where breakpoints and tests help the most.

DEBUGGING WITH PRINT STATEMENTS (AND WHY TO MOVE BEYOND THEM)

System.out.println is a fine first tool:

java

System.out.println("price=" + price + ", qty=" + qty);

System.out.println("price=" + price + ", qty=" + qty);

System.out.println("price=" + price + ", qty=" + qty);

Pros	Cons
Quick and simple	Clutters code and you must remove it later
Works anywhere	You must guess what to print
Good for first checks	Slow when the bug is deep or involves many variables

Better habit: use a debugger for inspection and a logger for permanent messages (see the logging section below).

USING THE INTELLIJ IDEA DEBUGGER (STEP BY STEP)

Other IDEs such as Eclipse and VS Code have the same ideas with different shortcuts.

Step 1: Set a breakpoint. Click in the left gutter next to a line number. A red dot appears. The program will pause there.

Step 2: Start in debug mode. Run the application with the Debug button (the bug icon), not the normal Run button.

Step 3: Inspect values. When execution pauses, look at the Variables panel to see the current values. Hover over a variable in the code to see its value.

Step 4: Control execution with the stepping buttons

Control	What it does	When to use it
Step Over	Runs the current line and moves to the next, without entering methods	Skip methods you trust
Step Into	Enters the method called on the current line	Investigate a method’s behaviour
Step Out	Runs the rest of the current method and returns to the caller	Leave a method you’re done with
Resume Program	Continues until the next breakpoint	Move quickly to the next point
Stop	Ends the debug session	Done

Step 5: Evaluate expressions. Use Evaluate Expression to test code while paused, for example student.getName().length() or list.size(), without editing your source.

Step 6: Watch variables. Add a watch to track a variable or expression as you step through.

Step 7: Use the Call Stack. The Frames or Call Stack panel shows how you reached this line, which is the live version of a stack trace. Click a frame to inspect variables at that level.

Debug session checklist

Check	Question
Value	Is the variable what I expected here?
Flow	Did execution enter the `if` or loop I expected?
Input	Is the data coming into this method correct?
Origin	Which caller passed the wrong value?

ADVANCED BREAKPOINTS (SAVE HOURS)

Feature	What it does	Example use
Conditional breakpoint	Pauses only when a condition is true	Pause only when `student.getId() == 105` inside a loop of 10,000
Exception breakpoint	Pauses when a chosen exception is thrown	Stop exactly where a `NullPointerException` occurs
Logging breakpoint	Prints a message without pausing	Trace values without editing code
Field watchpoint	Pauses when a field changes	Find who modifies `balance`
Mute breakpoints	Temporarily disables all breakpoints	Run normally for a while

Conditional breakpoints are the best tool for “it only fails for one record in a thousand”.

DEBUGGING A SPRING BOOT APPLICATION

Problem	What to check
Application fails to start	Read the last “Caused by” line. Often a missing bean, wrong property or port conflict.
`NoSuchBeanDefinitionException`	Missing `@Component`, `@Service` or `@Repository`, or the class is outside the scanned package
Port already in use	Another app uses port 8080. Stop it or change `server.port`.
Database connection error	Check URL, username, password and whether the database is running
404 Not Found	Check the mapping, HTTP method and URL path
405 Method Not Allowed	The URL exists, but the HTTP method differs
400 Bad Request	Check the request body, JSON format and validation rules
500 Internal Server Error	Open the server log and read the stack trace
JSON mapping problems	Check field names and types in your DTO or entity
Lazy loading errors in JPA	The session closed before data loaded. Fix with the right fetch strategy or DTO mapping.

Debugging a REST API call

Tip: turn on SQL logging in development to see generated queries, and turn it off in production. Configuration names depend on your Spring Boot and JPA versions, so check the documentation.

LOGGING BASICS (BETTER THAN SCATTERED PRINT STATEMENTS)

java

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class StudentService {
    private static final Logger log = LoggerFactory.getLogger(StudentService.class);

    public Student find(int id) {
        log.info("Finding student with id {}", id);
        Student s = repository.findById(id).orElse(null);
        if (s == null) {
            log.warn("Student {} not found", id);
        }
        return s;
    }
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class StudentService {
    private static final Logger log = LoggerFactory.getLogger(StudentService.class);

    public Student find(int id) {
        log.info("Finding student with id {}", id);
        Student s = repository.findById(id).orElse(null);
        if (s == null) {
            log.warn("Student {} not found", id);
        }
        return s;
    }
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class StudentService {
    private static final Logger log = LoggerFactory.getLogger(StudentService.class);

    public Student find(int id) {
        log.info("Finding student with id {}", id);
        Student s = repository.findById(id).orElse(null);
        if (s == null) {
            log.warn("Student {} not found", id);
        }
        return s;
    }
}

Log level	Use for
ERROR	Failures that need attention
WARN	Unexpected but handled situations
INFO	Important events (startup, key actions)
DEBUG	Detailed information for developers
TRACE	Very fine-grained details

Logging rules: log useful context (IDs, not secrets), never log passwords, tokens or personal data, and don’t log inside very hot loops.

DEBUGGING TECHNIQUES THAT SAVE HOURS

Technique	How it works
Binary search the bug	Check the middle of the flow. Is the data already wrong there? If yes, look earlier. If not, look later. Repeat.
Rubber-duck debugging	Explain the code line by line to an object or a friend. Hearing it often reveals the mistake.
Minimal reproducible example	Cut the code down to the smallest piece that still shows the bug.
Take a break	A short walk often helps you see the obvious.
Read the code, not your memory of it	Check what the code actually does, not what you meant it to do.
Use version control	`git diff` and `git log` show what changed since it last worked.
Write a failing test first	A test captures the bug and proves the fix.
Check assumptions	Verify inputs, configuration, versions and environment.
Search smartly	Use the exact error message, plus the library name and version.
Ask well	When asking a teammate, share the error, what you tried and the smallest code sample.

Small JUnit test that captures a bug

java

@Test
void returnsZeroForEmptyList() {
    assertEquals(0, calculator.average(List.of()));   // bug: divides by zero
}

@Test
void returnsZeroForEmptyList() {
    assertEquals(0, calculator.average(List.of()));   // bug: divides by zero
}

@Test
void returnsZeroForEmptyList() {
    assertEquals(0, calculator.average(List.of()));   // bug: divides by zero
}

THREE BUG-HUNT EXERCISES (TRY BEFORE LOOKING AT THE ANSWERS)

Exercise 1: Why does this print the wrong total?

java

int total = 0;
int[] marks = {80, 70, 90};
for (int i = 0; i <= marks.length; i++) {
    total += marks[i];
}
System.out.println(total);

int total = 0;
int[] marks = {80, 70, 90};
for (int i = 0; i <= marks.length; i++) {
    total += marks[i];
}
System.out.println(total);

int total = 0;
int[] marks = {80, 70, 90};
for (int i = 0; i <= marks.length; i++) {
    total += marks[i];
}
System.out.println(total);

Answer: i <= marks.length goes one step too far and throws ArrayIndexOutOfBoundsException. Use i < marks.length.

Exercise 2: Why is equals false?

java

String a = new String("java");
String b = new String("java");
System.out.println(a == b);

String a = new String("java");
String b = new String("java");
System.out.println(a == b);

String a = new String("java");
String b = new String("java");
System.out.println(a == b);

Answer: == compares references, so it prints false. Use a.equals(b) to compare content.

Exercise 3: Why does the program throw a NullPointerException?

java

Student s = repository.findById(10);   // returns null when not found
System.out.println(s.getName());

Student s = repository.findById(10);   // returns null when not found
System.out.println(s.getName());

Student s = repository.findById(10);   // returns null when not found
System.out.println(s.getName());

Answer: No student with id 10 exists, so s is null. Handle the missing case: check for null, or use Optional and decide what to do when nothing is found.

JAVA DEBUGGING INTERVIEW QUESTIONS

Question	Short answer
How do you debug a Java application?	Reproduce, read the stack trace, find the first line of my code, form a hypothesis, test it with a debugger or logs, fix and verify.
What is a stack trace?	A list of method calls that were active when an exception occurred, showing where it happened and how execution reached there.
What is a NullPointerException and how do you prevent it?	Using a reference that points to null. Prevent it with null checks, `Optional`, proper initialisation and validation.
Difference between checked and unchecked exceptions?	Checked ones must be handled or declared at compile time. Unchecked (runtime) ones need not be.
What is a breakpoint?	A marker that pauses execution so you can inspect state.
Step Over vs Step Into?	Step Over runs the line without entering methods. Step Into enters the called method.
How do you debug a bug that only happens sometimes?	Add logging with context, use conditional breakpoints, try to reproduce with the same data and check for concurrency or environment differences.
How do you find a memory leak?	Monitor memory use, take a heap dump and use a profiler to find objects that are never released.
Describe a bug you fixed in your project.	Describe the symptom, how you investigated, the root cause, the fix and what you learned.
What do you do when you’re stuck?	Reduce the problem, explain it aloud, search precisely, then ask a teammate with details.

How to answer “Describe a bug you fixed” (a 5-part structure)

Part	Example wording
Symptom	“The API returned a 500 error when a student had no courses.”
Investigation	“I read the stack trace and set a breakpoint in the service.”
Root cause	“A list was null for new students and I called `.size()` on it.”
Fix	“I initialised the list and added a unit test.”
Lesson	“I now validate inputs and test empty cases.”

Use a real bug from your own project, and don’t invent one.

COMMON MISTAKES FRESHERS MAKE WHILE DEBUGGING

Mistake	Why it hurts	Better approach
Ignoring the error message	The answer is often written there	Read it fully, slowly
Stopping at the first line of the trace	Library lines hide the root cause	Find your code and the last “Caused by”
Changing many things at once	You won’t know what fixed it	One change, one re-run
Only using print statements	Slow and messy	Learn the debugger
Catching an exception and doing nothing	Hides the bug	Log it or handle it properly
Copy-pasting a fix without understanding	The bug returns in another form	Understand why it works
Not reproducing consistently	You can’t confirm the fix	Find exact steps and data
Not adding a test after fixing	The bug may come back	Add a small test
Panicking	Clouds thinking	Take a breath and follow the method

A very common anti-pattern:

java

try {
    process();
} catch (Exception e) {
    // empty catch: the bug is now invisible
}

try {
    process();
} catch (Exception e) {
    // empty catch: the bug is now invisible
}

try {
    process();
} catch (Exception e) {
    // empty catch: the bug is now invisible
}

Always log or handle the exception: log.error("Processing failed", e);

14-DAY DEBUGGING PRACTICE PLAN

Day	Focus	Task
1	Mindset and method	Learn the 6 steps and write them on a card
2	Stack traces	Cause 5 different exceptions on purpose and read each trace
3	Common exceptions 1	Practise NullPointer, ArrayIndex and ClassCast fixes
4	Common exceptions 2	Practise NumberFormat, Arithmetic, ConcurrentModification
5	IntelliJ debugger	Set breakpoints, step over, step into, step out
6	Evaluate and watch	Use Evaluate Expression and watches on a small program
7	Advanced breakpoints	Use conditional and exception breakpoints
8	Logging	Add SLF4J logging to a project and use levels properly
9	Spring Boot startup errors	Break your own app (wrong property, missing bean) and fix it
10	REST API debugging	Debug a 400, 404 and 500 with Postman and breakpoints
11	Write failing tests	Capture 3 bugs in JUnit tests, then fix them
12	Bug-hunt exercises	Solve the three exercises, then create two of your own
13	Interview practice	Answer the interview table aloud, and prepare your own bug story
14	Review	Revisit weak areas and update your project README with a “bugs I fixed” section

MYTH VS REALITY

Myth	Reality
“Good developers don’t have bugs.”	Every developer debugs daily. Skill is in finding bugs fast.
“Debugging is just print statements.”	Debuggers, logs and tests are much more powerful.
“A long stack trace means a huge problem.”	Often the answer is in one or two lines.
“I should ask for help immediately.”	Try the method first, then ask with details.
“Fixing the symptom is enough.”	Find the root cause, or the bug returns.
“Debugging is only for Java experts.”	Beginners benefit the most from learning it early.

HOW VIBRANTMINDS HELPS FRESHERS BECOME CONFIDENT JAVA DEVELOPERS

VibrantMinds Technologies Pvt. Ltd. is a Pune-based IT training and placement support company. If you searched for VibrantMinds or VibrantMinds Technologies, here is what it offers:

Full Stack Java Development (about 4 to 6 months): Core Java, OOP, exception handling, JDBC, SQL, Spring Boot, REST APIs, front-end basics, projects, aptitude and interview preparation. Please check the candidate portal for the latest syllabus and tools.
Software Testing (Manual + Automation) (bug reporting and root-cause thinking), Core Java and Python & Data Science for other career paths
Project practice: Build projects, hit real bugs and learn to explain how you fixed them
Interview preparation: Technical rounds, project rounds, HR rounds, aptitude, communication and mock interviews
Placement support: Screening, drive coordination and interview support. Check https://candidates.vibrantminds.in/ for current openings.
Free WhatsApp job alert groups for fresher IT jobs, campus drives and walk-in alerts
Honesty first: VibrantMinds offers placement support, not a guaranteed job, and no legitimate recruiter should ask you to pay to be interviewed.

VibrantMinds works as a talent ecosystem connecting candidates, colleges and companies, with 1900+ partner colleges and 600+ hiring companies. More fresher job guidance: https://candidates.vibrantminds.in/blog/fresher-jobs-pune-2026

VIBRANTMINDS COURSES AT A GLANCE

Course	Duration	Key topics
Full Stack Java Development	4 to 6 months	Core Java, OOP, JDBC, SQL, Spring Boot, REST APIs, front-end basics, projects, aptitude and interview preparation
Software Testing (Manual + Automation)	2 to 5 months	Test cases, STLC, bug tracking, SQL, Selenium basics
Core Java	1 to 2 months	Syntax, OOP, collections, exceptions, strings
Python & Data Science	2 to 4 months	Python basics, data handling, analysis fundamentals

Fees, syllabus and batch dates are on https://candidates.vibrantminds.in/. Please confirm them directly before enrolling.

THE VIBRANTMINDS PLACEMENT PIPELINE: SIX STEPS

REAL OUTCOMES: WHAT TO EXPECT AND WHAT NOT TO

Past students have shared positive feedback about the training and support, and have gone on to roles at companies such as Aress Software and Education Technologies, Saama Technologies and Three M Software. Results vary by candidate, skill level, effort and market conditions, so please confirm details directly with the VibrantMinds team. No one can honestly promise a guaranteed job.

JOIN FREE VIBRANTMINDS WHATSAPP GROUPS: FREE IT JOB UPDATES FOR JAVA FRESHERS IN PUNE AND INDIA

Looking for free WhatsApp groups, free IT job WhatsApp groups, a Java WhatsApp group for freshers or a job updates WhatsApp group in India? The VibrantMinds groups share fresher IT openings, campus drives, walk-in interview alerts and interview preparation updates, free of charge. Join whichever group has space. All three carry the same type of updates.

Group	What it offers	Link
VibrantMinds Fresher IT Jobs, Group 1	Fresher openings, campus drives, walk-in alerts	https://chat.whatsapp.com/CUCS1derlmTFee2c9dyUHd
VibrantMinds Fresher IT Jobs, Group 2	Fresher openings, campus drives, walk-in alerts	https://chat.whatsapp.com/FvMf1fGYQYnHppQ8AwFX40
VibrantMinds Fresher IT Jobs, Group 3	Fresher openings, campus drives, walk-in alerts	https://chat.whatsapp.com/I7RNnGMkb2L8S8HibdyWpQ

Never pay to apply. Legitimate recruiters do not charge candidates for tests, interviews or offer letters. Do not share sensitive personal or financial details in any group chat.

FREQUENTLY ASKED QUESTIONS

1. How do I debug Java code step by step as a beginner?
Reproduce the problem, read the error message and stack trace, find the first line of your own code in the trace, guess the cause, test the guess using a breakpoint, a log line or a small experiment, then fix it and re-run. Change one thing at a time, and add a small test so the bug doesn’t return.

2. How do I read a Java stack trace and find the root cause?
Read the exception type and message first. Then find the first line that belongs to your own package, because that’s usually where to look. For long traces with several “Caused by” sections, scroll to the last “Caused by”, since that often shows the root cause.

3. How do I fix a NullPointerException in Java?
Find which reference is null using the message and line number, then trace back where it should have been set. Fix it by initialising the object, checking for null before use, using Optional or correcting the code that returned null. Don’t just add a null check without understanding why the value was missing.

4. How do I use breakpoints in IntelliJ IDEA?
Click the left gutter next to a line to set a breakpoint, run the app in Debug mode, inspect values in the Variables panel and use Step Over, Step Into and Step Out to move through the code. Use Evaluate Expression to test code while paused, and conditional breakpoints to stop only when a condition is true.

5. Is there a free WhatsApp group for Java freshers in Pune?
Yes. VibrantMinds runs free fresher IT job WhatsApp groups that share Java and other IT openings, campus drives and walk-in alerts. Join through the links above, and always verify a job post and never pay to apply.

CONCLUSION: DEBUGGING IS A SKILL YOU CAN TRAIN

Learning how to debug Java code turns frustration into a repeatable process: reproduce, read the stack trace, locate your code, form a hypothesis, test with the debugger or logs, fix and verify. Practise on small bugs, learn the common exceptions, use breakpoints and logging, and keep a short “bugs I fixed” story ready for interviews. Follow the 14-day plan and you’ll gain a skill that employers value from day one.

If you’re in Pune and want structured Java training with real project practice, interview preparation and placement support, VibrantMinds Technologies is here to help.

Call to action: