Exception Handling in Java

Introduction

Java exceptions are events that disrupt the normal flow of a program during runtime. They are objects representing errors or unusual conditions that the program should handle to prevent crashing or unexpected behaviour.

Types of Java Exceptions

1.Checked Exceptions

• These are exceptions that are checked at compile time

• The program must handle these exceptions using a try-catch block or declare them using the throws keyword.

• Examples: IOException, SQLException, FileNotFoundException.

2.Unchecked Exceptions

• These occur during runtime and are not checked at compile time.

• They usually result from programming errors, such as logic mistakes or improper use of APIs.

• Examples: NullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException.

3.Errors

• Represent serious problems that applications should not try to catch.

• Examples: OutOfMemoryError, StackOverflowError.

Exception Handling in Java

Java uses the following keywords for exception handling:

1. try: Code that might throw an exception is enclosed in a try block.
2. catch: Handles specific exceptions thrown by the try block.
3. finally: Block that is always executed after try and catch, regardless of whether an exception occurred.
4. throw: Used to explicitly throw an exception.
5. throws: Declares exceptions that a method might throw.

Syntax Example

import java.io.*;

public class ExceptionExample {
    public static void main(String[] args) {
        try {
            // Code that may throw an exception
            FileInputStream file = new FileInputStream("test.txt");
        } catch (FileNotFoundException e) {
            // Handling the exception
            System.out.println("File not found: " + e.getMessage());
        } finally {
            // Always executed
            System.out.println("Execution completed.");
        }
    }
}

Commonly Used Exception Classes

IOException: Input-output operations failure.
SQLException: Database access errors.
ClassNotFoundException: Class not found during runtime.
ArithmeticException: Invalid arithmetic operations (e.g., division by zero).
NullPointerException: Attempt to use an object reference that is null.
IllegalArgumentException: Method has been passed an inappropriate argument.

Custom Exceptions

You can create custom exceptions by extending the Exception or RuntimeException class.

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

public class CustomExceptionExample {
    public static void main(String[] args) {
        try {
            throw new MyCustomException("Custom error occurred");
        } catch (MyCustomException e) {
            System.out.println(e.getMessage());
        }
    }
}

Summary

Java exceptions are critical for handling errors and maintaining application stability. They are categorized into checked exceptions (like IOException) that are handled at compile-time, unchecked exceptions (like NullPointerException) that occur during runtime, and errors (like OutOfMemoryError) indicating serious issues.

Java's robust exception-handling mechanism includes keywords like try, catch, finally, throw, and throws, allowing developers to manage errors gracefully. Custom exceptions can also be created to address application-specific issues. By effectively leveraging Java's exception handling, developers can build resilient and user-friendly applications. Happy Coding!!