Show List
Tutorials > Java > Java Exception Handling Explained with Examples

Java Exception Handling Explained with Examples

Exception handling in Java is a crucial feature that allows developers to gracefully manage runtime errors without crashing the entire program. Rather than letting the program terminate unexpectedly, Java provides structured mechanisms—such as try, catch, throw, and custom exceptions—to detect and handle errors dynamically. Whether it’s handling built-in exceptions like ArithmeticException or creating custom ones like InvalidInputException, mastering exception handling is essential for writing robust and error-resistant Java applications.


What is Exception Handling in Java?

Exception handling in Java is a mechanism to manage unexpected errors during runtime. It enables the program to catch exceptions, respond to them, and continue executing without crashing.

Built-in Exception Example:
try {
    int a = 5 / 0; // Division by zero
} catch (ArithmeticException e) {
    System.out.println("An arithmetic exception has occurred: " + e.getMessage());
}

Explanation:

  • The division by zero throws an ArithmeticException.

  • The catch block catches and handles the exception, allowing the program to continue.

🛠️ Custom Exception Example

Java also allows you to define your own exception classes by extending the Exception class.

class InvalidInputException extends Exception {
    public InvalidInputException(String message) {
        super(message);
    }
}

try {
    String input = "";
    if (input.equals("")) {
        throw new InvalidInputException("Input cannot be empty.");
    }
} catch (InvalidInputException e) {
    System.out.println("An invalid input exception has occurred: " + e.getMessage());
}

Explanation:

  • A custom exception InvalidInputException is created.

  • If the input is empty, the program throws this custom exception.

  • The catch block handles it and displays a meaningful message.

Why Use Exception Handling?

  • Prevents Program Crashes
    Handle runtime errors without terminating the program.

  • Improves Readability
    Separates error-handling logic from regular code.

  • Enhances Robustness
    Create fallback logic and user-friendly error messages.

  • Supports Custom Behavior
    Design your own exception types for domain-specific error handling.


Common Keywords in Java Exception Handling

KeywordDescription
tryBlock of code to test for errors
catchHandles the exception
throwManually throws an exception
throwsDeclares exception a method might throw
finallyExecutes code regardless of exception

Exception handling is a powerful Java feature that ensures your programs remain stable and reliable even when unexpected situations occur. By using try-catch blocks and defining custom exceptions, you can provide clear error messages and maintain control over your application’s behavior. Keep practicing by introducing exception handling into your projects and explore related topics like finally, throws, and exception chaining to further solidify your understanding.


FAQ Section

Q1. What happens if I don’t handle an exception in Java?

If an exception is not caught, it will propagate up the call stack and may terminate the program if left unhandled.

Q2. Can I have multiple catch blocks for a single try block?

Yes, you can have multiple catch blocks to handle different types of exceptions separately.

Q3. What is the difference between throw and throws in Java?

throw is used to manually throw an exception, while throws is used in method signatures to declare exceptions that might be thrown.

Q4. When should I create custom exceptions?

Create custom exceptions when built-in types don’t clearly represent the error context in your domain logic.

Q5. What is the use of the finally block?

The finally block is used to execute cleanup code (e.g., closing files or connections) regardless of whether an exception was thrown.



Next: Quiz - Java Exceptions - 1

    Leave a Comment

  • captcha text