Types of exception in Java

In Java, there are two main types of exceptions: checked exceptions and unchecked exceptions.

1. Checked exceptions:

Checked exceptions are exceptions that are checked at compile time. This means that the code must handle them or declare them to be thrown. Checked exceptions typically represent errors that can be anticipated and handled gracefully. Examples of checked exceptions include IOException, SQLException, and ClassNotFoundException.

For example, if a method attempts to read from a file, it must handle the possibility that the file does not exist or is not readable. This is typically done by wrapping the file operation in a try-catch block that catches the IOException that may be thrown.

Here's an example of using a try-catch block to handle a checked exception:

                
    try {
        FileReader file = new FileReader("example.txt");
        BufferedReader reader = new BufferedReader(file);
        String line = reader.readLine();
    } catch (IOException e) {
        e.printStackTrace();
    }
2. Unchecked exceptions:

Unchecked exceptions are exceptions that are not checked at compile time. They are typically caused by programming errors or unexpected runtime conditions. Examples of unchecked exceptions include NullPointerException, ArrayIndexOutOfBoundsException, and IllegalArgumentException.

For example, if a method attempts to access an array element that does not exist, an ArrayIndexOutOfBoundsException is thrown. This type of exception is typically caused by a programming error, such as an off-by-one error in an array index calculation.

In general, unchecked exceptions represent more serious errors that are difficult to recover from. Unlike checked exceptions, unchecked exceptions do not need to be declared in a method's throws clause, although they can still be caught and handled using try-catch blocks.

It's important to note that all exceptions in Java inherit from the Throwable class. This class is the top-level class in the Java exception hierarchy, with sub-classes for Error and Exception. Errors represent serious system errors that cannot be recovered from, while Exceptions represent recoverable errors that can be caught and handled.

Here's an example of using a try-catch block to handle an unchecked exception:

                
    int a = 10;
    int b = 0;
    try {
        int c = a / b;
    } catch (ArithmeticException e) {
        e.printStackTrace();
    }
3. Error:

Errors: These are exceptions that are thrown to indicate a serious problem that should not be caught or handled by the application. Examples of errors include OutOfMemoryError and StackOverflowError.

Here's an example of using a try-catch block to handle an error (which is not recommended):

                
    try {
        // code that might cause an error
    } catch (Error e) {
        e.printStackTrace();
    }

In general, it is a good practice to handle exceptions in Java using try-catch blocks. This can help to prevent unexpected behavior and improve the robustness of the program. However, it is also important to handle exceptions correctly and not to catch or handle errors that should not be caught or handled.

Next Post