Custom Exceptions in Java

Why custom exceptions

Java's built-in exceptions cover general errors, but sometimes you want an error that describes your program's rules — like withdrawing more money than you have. A custom exception is your own exception class with a clear name and message, making errors easier to understand and handle.

Quick exception recap

try {
    int x = 5 / 0;             // throws ArithmeticException
} catch (ArithmeticException e) {
    System.out.println("Caught: " + e.getMessage());
}

Exceptions are errors you can catch with try-catch. Built-in ones like ArithmeticException are useful, but custom ones let you describe your own error situations.

Creating your own exception

class InsufficientBalanceException extends Exception {
    InsufficientBalanceException(String message) {
        super(message);        // pass message to Exception
    }
}

To make a custom exception, extend Exception and add a constructor that passes a message to super. That is all it takes to have your own named error type.

Throwing and catching it

void withdraw(int balance, int amount)
        throws InsufficientBalanceException {
    if (amount > balance) {
        throw new InsufficientBalanceException("Not enough money");
    }
    System.out.println("Withdrawn: " + amount);
}
// use:
try {
    withdraw(100, 500);
} catch (InsufficientBalanceException e) {
    System.out.println("Error: " + e.getMessage());
}

Use throw new ... to raise it, and throws in the method to declare it. The caller catches it just like any exception.

Passing a message

Passing a message to super(message) means getMessage() returns it when caught. A good message explains what went wrong — "Not enough money" is far clearer than a generic error, which helps you and other developers debug quickly.

Checked vs unchecked

• Checked (extends Exception) — must be caught or declared with throws. Use for recoverable situations.
• Unchecked (extends RuntimeException) — no need to declare. Use for programming errors.

Choose checked when the caller should be forced to handle the case, unchecked for bugs that should just fail.

Common mistakes

• Not passing the message to super. Then getMessage() returns null.
• Forgetting throws for checked exceptions. The compiler requires it or a catch.
• Confusing throw and throws. throw raises it; throws declares it.
• Overusing custom exceptions. Only create them for meaningful, specific situations.

Summary

• A custom exception describes your program's own errors clearly.
• Create it by extending Exception or RuntimeException.
• Pass a message to super so getMessage() works.
• Use throw to raise it and throws to declare it.
• Checked must be handled; unchecked need not be.

Next, learn cleanup with final, finally and finalize, or organise code with Java methods.