Skip to content

Java Exceptions

So, what exactly are exceptions, you ask? Well, think of them as little red flags that pop up when something unexpected happens in your code—like a surprise twist in your favorite story. Exceptions occur when the normal flow of a program is disrupted by unforeseen circumstances, such as invalid input, file not found, or trying to do something impossible.

Now, let's make this concept a bit more concrete with an example

Imagine you're baking a cake following a recipe. You carefully measure the ingredients and follow each step, but suddenly you realize you're out of flour! That's like an exception in programming—it's when something unexpected happens that prevents your code from doing what it's supposed to do.

In Java, exceptions come in different types, each representing a specific kind of problem. Some common exceptions include NullPointerException, ArrayIndexOutOfBoundsException, and FileNotFoundException. Each one tells you something went wrong and helps you figure out how to fix it.

But here's the cool part: Java gives us tools to handle these exceptions gracefully, like catching them with try-catch blocks or throwing them to let other parts of our code deal with them. It's like having a safety net to catch us when we fall, allowing our programs to recover from errors and continue running smoothly.

Types of exceptions

Checked Exceptions:

These are the responsible citizens of the exception world. Checked exceptions are like well-behaved guests at a party—they politely inform you that something might go wrong, and it's your job to handle it. When you encounter a checked exception, Java requires you to handle it either by catching it or by declaring it in the method signature using the throws keyword.

Unchecked Exceptions

Unchecked exceptions don't play by the rules—they can occur at runtime, catching you off guard when you least expect it. Unlike checked exceptions, Java doesn't force you to handle unchecked exceptions explicitly. Instead, they're usually caused by programming errors or conditions beyond your control.


These are the most serious type of exception, often indicating a catastrophic failure that's beyond your program's ability to recover from. Errors are like the final boss battle in a video game—once they appear, it's game over. Common examples include OutOfMemoryError and StackOverflowError.

Now, let's put this into context with a simple example:

public class ExceptionExample {
    public static void main(String[] args) {
        try {
            // Let's attempt to divide by zero
            int result = 10 / 0;
            System.out.println("Result: " + result); // This line won't execute
        } catch (ArithmeticException e) {
            System.out.println("Oops! Something went wrong: " + e.getMessage());

In this example, we're attempting to divide by zero, which triggers an ArithmeticException, an unchecked exception. We catch this exception using a try-catch block and handle it by printing a friendly error message.

Java Exception keywords

tryIndicates a block of code that may throw an exception.
catchCatches exceptions thrown by the try block.
finallySpecifies a block of code that will always be executed, regardless of whether an exception occurs.
throwThrows an exception manually.
throwsSpecifies that a method may throw certain exceptions.
ExceptionBase class for all exceptions.
RuntimeExceptionBase class for unchecked exceptions.
ErrorIndicates serious problems that usually can't be recovered from.

Waytojava is designed to make learning easier. We simplify examples for better understanding. We regularly check tutorials, references, and examples to correct errors, but it's important to remember that humans can make mistakes.