Thinking about Exceptions

Let's Think a Little Bit About Exceptions What Is an Exception? An exception is an event that occurs unexpectedly and disrupts the normal flow of a program. We never write code thinking, "This should be a good exception!" On the contrary, exceptions happen when something goes wrong beyond our control or planning. Therefore, handling exceptions properly is crucial to ensuring that our system remains robust and reliable. Checked vs. Unchecked Exceptions Whether you're using Java or Kotlin, exceptions are an essential part of the language. Let's explore the hierarchy behind exception handling. Checked Exceptions Checked exceptions are exceptions that are verified at compile time. This means that the compiler forces you to handle them either by using a try-catch block or by propagating them with the throws keyword. The base class for checked exceptions is Exception (excluding RuntimeException and its subclasses). Examples: IOException, SQLException, FileNotFoundException. Unchecked Exceptions Unchecked exceptions occur during runtime and are not checked at compile time. They usually arise due to logical errors in the program, such as accessing a null reference or an invalid index. The base class for unchecked exceptions is RuntimeException. Examples: NullPointerException, ArrayIndexOutOfBoundsException, IllegalArgumentException. Handling and Throwing Exceptions In Java, you can either handle exceptions directly or propagate them to the caller. Let’s look at both approaches. Handling Exceptions The most common way to handle exceptions is by using a try-catch-finally block: try { yourMethod(); // Additional logic } catch (IOException e) { // Log the stack trace or throw a custom exception throw new CustomException("Error executing the method", e); } finally { // Cleanup resources, such as closing files or database connections }

Feb 14, 2025 - 00:25

Let's Think a Little Bit About Exceptions

What Is an Exception?

An exception is an event that occurs unexpectedly and disrupts the normal flow of a program. We never write code thinking, "This should be a good exception!" On the contrary, exceptions happen when something goes wrong beyond our control or planning.

Therefore, handling exceptions properly is crucial to ensuring that our system remains robust and reliable.

Checked vs. Unchecked Exceptions

Whether you're using Java or Kotlin, exceptions are an essential part of the language. Let's explore the hierarchy behind exception handling.

Checked Exceptions

Checked exceptions are exceptions that are verified at compile time. This means that the compiler forces you to handle them either by using a try-catch block or by propagating them with the throws keyword. The base class for checked exceptions is Exception (excluding RuntimeException and its subclasses).

Examples: IOException, SQLException, FileNotFoundException.

Unchecked Exceptions

Unchecked exceptions occur during runtime and are not checked at compile time. They usually arise due to logical errors in the program, such as accessing a null reference or an invalid index. The base class for unchecked exceptions is RuntimeException.

Examples: NullPointerException, ArrayIndexOutOfBoundsException, IllegalArgumentException.

Handling and Throwing Exceptions

In Java, you can either handle exceptions directly or propagate them to the caller. Let’s look at both approaches.

Handling Exceptions

The most common way to handle exceptions is by using a try-catch-finally block:

try {
    yourMethod(); 
    // Additional logic
} catch (IOException e) {
    // Log the stack trace or throw a custom exception
    throw new CustomException("Error executing the method", e);
} finally {
    // Cleanup resources, such as closing files or database connections
}