Types of Exception in Java: Checked, Unchecked, and Errors Explained

Exceptions are one of the most important concepts in Java, and so are the types of exception in Java. They help developers handle unexpected situations that occur while a program is running. Without exception handling, a simple error like dividing by zero or accessing a missing file can cause the entire application to crash. 

This blog explains the types of exception in Java, their hierarchy, real-world examples, and how developers handle them effectively. You'll also learn the different types of exceptions in Java with examples and understand where each exception category is commonly used in applications. 

Explore upGrad's Data Science, AI, and Machine Learning programs to strengthen your foundation in Java fundamentals, including operators, variables, control flow, and object-oriented programming concepts. 

What Are Exceptions in Java? 

An exception is Java's way of saying something went wrong. It's not a bug in the traditional sense. It's a signal that the program hit a condition it wasn't prepared to handle. 

Java uses a class hierarchy for this. Every exception is an object. At the top sits java.lang.Throwable. Below it, two branches split out: Exception and Error. 

Knowing which branch you're dealing with changes how you respond. 

Instead of abruptly terminating the program, Java gives developers a chance to handle the problem and continue execution where appropriate. Consider a banking application. A customer tries to withdraw money from an account that doesn't exist. Rather than crashing, the system can display a meaningful message and ask the user to try again. 

Here's what happens when an exception occurs: 

Step	Description
Exception occurs	An unexpected condition arises
Exception object created	JVM creates an exception object
Exception thrown	Control moves to exception handler
Exception handled	Program responds appropriately
Program continues	Execution proceeds if possible

Why Exception Handling Matters 

Imagine processing thousands of online transactions every minute. A single invalid input shouldn't stop the entire system. That's where exception handling becomes essential.  

Exception handling helps developers: 

• Prevent program crashes  
• Improve user experience  
• Maintain application stability  
• Simplify debugging  
• Handle unexpected inputs safely  

Basic Example 

public class Example { 
    public static void main(String[] args) { 
        int result = 10 / 0; 
        System.out.println(result); 
    } 
} 

This code throws an ArithmeticException because division by zero isn't allowed. 

The JVM detects the issue instantly. Execution stops unless the exception is handled. 

Also read: Checked And Unchecked Exceptions | upGrad Tutorials 

The Java Exception Hierarchy 

Understanding the types of exception in Java starts with understanding the exception hierarchy. 

Java exceptions are broadly divided into two categories: 

1. Checked Exceptions  
2. Unchecked Exceptions  

These categories fall under the Exception class, which itself extends the Throwable class.  

Checked Exceptions in Java 

Checked exceptions are the ones the compiler forces you to deal with. If you call a method that throws a checked exception and you don't handle it or declare it, your code won't compile. That's the point. The compiler wants you to think about failure before it happens. 

Common Checked Exceptions 

Exception	When It Occurs
IOException	File not found or unreadable
SQLException	Database query fails
ClassNotFoundException	Class not found at runtime
FileNotFoundException	Specific file doesn't exist
InterruptedException	Thread interrupted during sleep or wait

Here's a real example. You're reading a file: 

import java.io.*; 
  
public class ReadFile { 
    public static void main(String[] args) { 
        try { 
            FileReader file = new FileReader("data.txt"); 
            BufferedReader br = new BufferedReader(file); 
            System.out.println(br.readLine()); 
            br.close(); 
        } catch (IOException e) { 
            System.out.println("File error: " + e.getMessage()); 
        } 
    } 
} 

The try-catch block is mandatory here. Skip it and the code won't compile. 

Checked exceptions are your contract with the caller. They say: this operation might fail, and you're responsible for deciding what happens when it does. 

One thing worth noting. Wrapping everything in a broad catch (Exception e) block defeats the purpose. Catch specific exceptions. Handle them specifically. 

Unchecked Exceptions in Java 

Unchecked exceptions extend RuntimeException. The compiler doesn't enforce handling. These happen at runtime, and that's what makes them tricky. 

You don't get a warning. The program just crashes. 

Common Unchecked Exceptions with Examples 

NullPointerException 

Probably the most common one in Java. It happens when you try to use an object reference that points to nothing. 

java 
String name = null; 
System.out.println(name.length()); // Throws NullPointerException 

ArrayIndexOutOfBoundsException 

You tried to access an index that doesn't exist. 

java 
int[] nums = {1, 2, 3}; 
System.out.println(nums[5]); // Throws ArrayIndexOutOfBoundsException 

ArithmeticException 

Dividing by zero triggers this. 

java 
int result = 10 / 0; // Throws ArithmeticException 

ClassCastException 

Forcing an object into a type it isn't. 

java 
Object obj = "Hello"; 
Integer num = (Integer) obj; // Throws ClassCastException 

NumberFormatException 

Parsing a string that isn't actually a number. 

java 
int n = Integer.parseInt("abc"); // Throws NumberFormatException 

Here's a comparison of the different types of exceptions in Java with examples summarized: 

Exception Type	Checked/Unchecked	Compile-time Enforced
IOException	Checked	Yes
NullPointerException	Unchecked	No
SQLException	Checked	Yes
ArithmeticException	Unchecked	No
ClassNotFoundException	Checked	Yes
ArrayIndexOutOfBoundsException	Unchecked	No

Unchecked exceptions don't mean you should ignore them. They mean Java trusts you to write logic that avoids them. If you're calling a method that might return null, check before using it. 

Must read: Identifiers in Java: Key Concepts, Syntax, Examples, and Best Practices to Know in 2025 

 

Errors in Java: When the JVM Itself Fails 

Errors sit outside the Exception branch entirely. They come from Error, and they signal problems that are usually beyond your control. 

Don't try to catch most errors. They indicate the JVM is in a state it can't recover from. 

Types of Errors 

StackOverflowError  

This happens with infinite or deeply recursive method calls. The call stack fills up. 

java 
public static void recursive() { 
   recursive(); // Keeps calling itself 
} 

OutOfMemoryError 

The JVM runs out of heap space. Usually seen in applications handling large datasets or memory leaks. 

AssertionError 

An assertion in the code failed. Uncommon in production, but relevant during testing. 

You might catch StackOverflowError in some specific frameworks or logging scenarios, but for most applications, errors signal something structurally broken. Fix the code, don't catch the error. 

Also read: Control Statements in Java: Types, Flowcharts, and Code Examples 

Types of Exception Handling in Java 

Knowing the types is only half the work. You also need to know the mechanics of types of exception handling in Java. 

try-catch 

The basic block. Write risky code in try, handle the fallout in catch. 

java 
try { 
   int result = 10 / 0; 
} catch (ArithmeticException e) { 
   System.out.println("Can't divide by zero"); 
} 

try-catch-finally 

The finally block runs no matter what. It's where you close resources. 

java 
FileReader fr = null; 
try { 
   fr = new FileReader("file.txt"); 
} catch (IOException e) { 
   System.out.println(e.getMessage()); 
} finally { 
   if (fr != null) fr.close(); 
} 

try-with-resources 

Cleaner syntax for auto-closing resources. Introduced in Java 7. 

java 
try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) { 
   System.out.println(br.readLine()); 
} catch (IOException e) { 
   System.out.println(e.getMessage()); 
} 

throws Keyword 

If a method can throw a checked exception and you don't want to handle it there, you declare it with throws. The caller takes responsibility. 

java 
public void readFile(String path) throws IOException { 
   FileReader fr = new FileReader(path); 
} 

throw Keyword 

You can throw your own exceptions manually. Useful when a condition that violates your logic is met. 

java 
public void setAge(int age) { 
   if (age < 0) { 
       throw new IllegalArgumentException("Age can't be negative"); 
   } 
   this.age = age; 
} 

Do read: Types of Variables in Java: The Building Blocks of Clean Code 

Custom Exceptions in Java 

Java lets you create your own exception types. This is useful when your application has domain-specific error conditions that don't map to any built-in exception. 

java 
public class InsufficientFundsException extends Exception { 
   public InsufficientFundsException(String message) { 
       super(message); 
   } 
} 
 
public class BankAccount { 
   private double balance = 500; 
 
   public void withdraw(double amount) throws InsufficientFundsException { 
       if (amount > balance) { 
           throw new InsufficientFundsException("Not enough balance"); 
       } 
       balance -= amount; 
   } 
} 

Custom exceptions make your error messages meaningful. They also make debugging faster because the exception name itself tells you what went wrong. 

Extend Exception for checked custom exceptions. Extend RuntimeException for unchecked ones. Pick based on whether you want to force callers to handle it. 

Must read: Data Types in Java: Primitive & Non-Primitive Data Types 

Common Mistakes When Handling Exceptions 

Even experienced developers get this wrong. Here are the patterns you want to avoid. 

• Swallowing exceptions silently. An empty catch block hides problems instead of solving them. 
• Catching Exception for everything. You lose specificity. A NullPointerException and an IOException need different responses. 
• Using exceptions for flow control. Don't throw exceptions to manage normal logic branches. They're expensive. 
• Not logging the stack trace. e.getMessage() alone isn't enough. Log e or call e.printStackTrace() so you have context. 
• Catching Error. Unless you have a very specific reason, don't do it. 

 

Conclusion 

Java's exception system is structured for a reason. Checked exceptions make you plan for predictable failures. Unchecked exceptions flag bugs in your logic. Errors tell you the JVM itself is in trouble. 

Once you understand the types of exception in Java clearly, exception handling stops feeling like boilerplate and starts feeling like actual defensive programming. Handle what you can, declare what you can't, and never hide what you don't understand. 

If you want to build stronger fundamentals in Java, upGrad's Java programming courses take you from basics to production-level skills with hands-on projects and mentorship. 

Ready to start your journey? Book a free consultation with upGrad today to find the best path for your career.