Understanding Exception Handling in Java

This Java program demonstrates the essential concepts of exception handling using the try-catch-finally construct. Exception handling is crucial for dealing with unexpected errors that may occur during program execution.

It shows different mechanisms on how to handle exceptions, catch errors and show error messages. Exception handling helps manage errors gracefully during program execution. The try-catch-finally structure provides a mechanism to handle exceptions, ensuring proper program behavior even in the presence of unexpected issues. Custom exceptions can be created to convey specific error information.

The following Java code serves as a fundamental example for novice Java programmers to grasp the basics of exception handling in Java.

public class UsingExceptions {

    public static void main(String args[]) {
        try {
            throwException();
        } catch (CustomException e) {
            System.err.println("CustomException handled in main: " + e.getMessage());
        }

        doesNotThrowException();
    }

    public static void throwException() throws CustomException {
        try {
            System.out.println("Method throwException");
            throw new CustomException("CustomException occurred"); // generate custom exception
        } catch (CustomException e) {
            System.err.println("CustomException handled in method throwException: " + e.getMessage());
            throw e; // rethrow for further processing
        } finally {
            System.err.println("Finally executed in throwException");
        }
    }

    public static void doesNotThrowException() {
        try {
            System.out.println("Method doesNotThrowException");
            // No exception thrown in this method
        } catch (Exception e) {
            System.err.println(e.toString());
        } finally {
            System.err.println("Finally executed in doesNotThrowException");
        }

        System.out.println("End of method doesNotThrowException");
    }
}

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

How this Java Code Works?

Here is a break down of the above Java program.

The main() Method:

• The main method is the starting point of the program.
• It contains a try block where the throwException method is called, which intentionally throws a custom exception.
• The catch block catches the custom exception (CustomException) and prints an error message to indicate that the exception has been handled.

The throwException() Method:

• This method illustrates the process of throwing and catching exceptions.
• Within the try block, it prints a message and throws a custom exception (CustomException).
• The catch block catches the custom exception, prints an error message, and rethrows the exception for further processing.
• The finally block is executed regardless of whether an exception is thrown or not. It is useful for cleanup operations.

The doesNotThrowException() Method:

• This method demonstrates a scenario where no exception is thrown.
• The try block contains code that does not throw any exception.
• The catch block is not triggered because there is no exception to catch.
• The finally block is executed to demonstrate its role in cleanup operations.

CustomException Class:

• A custom exception class (CustomException) is defined to showcase the creation of user-defined exceptions.
• It extends the built-in Exception class and has a constructor for providing a custom error message.