Exception Handling in Java

⚠️ Exception Handling in Java

When developing Java applications, unexpected problems such as invalid input or file errors can occur during runtime. Exception Handling in Java is the process that allows your program to respond to these errors gracefully instead of crashing abruptly.

This tutorial will explain how to handle exceptions effectively, keeping your applications stable and user-friendly.

🔍 What is an Exception?

An exception is an event that disrupts the normal flow of a program. It can be caused by errors like dividing by zero, accessing an invalid array index, or file not found scenarios.

Java treats exceptions as objects, and they are part of the Throwable class hierarchy.

🛠️ The Try-Catch Block

The most common way to handle exceptions is by using the try-catch block. Code that might throw an exception is placed inside try, and the exception handling code goes inside catch.

try {
    int result = 10 / 0;  // This will throw ArithmeticException
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero!");
}

🔄 Using finally Block

The finally block contains code that always executes, regardless of whether an exception was thrown or caught.

It’s typically used to release resources like closing files or database connections.

try {
    int[] numbers = {1, 2, 3};
    System.out.println(numbers[5]);  // ArrayIndexOutOfBoundsException
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Index is out of range!");
} finally {
    System.out.println("This will run no matter what.");
}

📤 throw vs throws

Java provides two keywords related to exceptions:

• throw is used to explicitly throw an exception from a method or block.
• throws declares exceptions that a method might throw, forcing the caller to handle or declare them.

public void checkAge(int age) throws IllegalArgumentException {
    if (age < 18) {
        throw new IllegalArgumentException("Age must be 18 or older.");
    }
}

⚖️ Checked vs Unchecked Exceptions

Java exceptions fall into two categories:

• Checked Exceptions: These must be either caught or declared in the method signature. Examples include IOException and SQLException.
• Unchecked Exceptions: These extend RuntimeException and don't need explicit handling. Examples are NullPointerException and ArithmeticException.

📝 Creating Custom Exceptions

Sometimes, built-in exceptions don’t cover your needs. You can create your own by extending the Exception class:

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

// Usage
public void test() throws MyException {
    throw new MyException("This is a custom exception.");
}

💡 Best Practices for Exception Handling

• Catch only those exceptions you can handle meaningfully.
• Avoid empty catch blocks; always log or handle the error.
• Use specific exceptions instead of catching general Exception.
• Clean up resources in a finally block or use try-with-resources.
• Document exceptions your methods can throw using throws.

🚀 Conclusion

Mastering Exception Handling in Java helps you build resilient programs that can handle unexpected problems smoothly.

Using try-catch, finally, throw, and throws wisely not only prevents crashes but also improves user experience and application reliability.