Exceptions

Exceptions are a way to handle errors in Java. They are objects that are thrown when an error occurs in a program. When an exception is thrown, the program stops executing and the exception is passed to the calling method. If the calling method does not handle the exception, the exception is passed to the next method in the call stack. If no method handles the exception, the program terminates.

Generally, you should use exceptions to handle errors that are outside your control.

An exception essentially just throws the responsibility of handling the error to the calling method. This allows you to separate the error handling code from the normal code, making your code cleaner and easier to read.

Throwing Exceptions

To throw an exception in Java, you use the throw keyword followed by an instance of an exception class. For example, to throw an ArithmeticException, you would write:

throw new ArithmeticException("Division by zero");

Handling Exceptions

There are two ways to handle exceptions in Java: using a try-catch block or using a throws clause.

Try-Catch Blocks

A try-catch block is used to catch exceptions that are thrown in the try block. If an exception is thrown in the try block, the program will jump to the catch block and execute the code there. If no exception is thrown, the catch block is skipped.

try {
    // code that may throw an exception
} catch (Exception e) {
    // code to handle the exception
}

Throws Clause

A throws clause is used to declare that a method may throw an exception. If a method throws an exception and does not handle it, the exception is passed to the calling method. If the calling method does not handle the exception, the exception is passed to the next method in the call stack.

public void myMethod() throws Exception {
    // code that may throw an exception
}

Question: Throw vs. Throws

What is the difference between throw and throws in Java?

• throw is used to throw an exception in a method.
• throws is used to declare that a method may throw an exception.

Exception Hierarchy

In Java, exceptions are organized in a hierarchy. At the top of the hierarchy is the Throwable class, which is the superclass of all exceptions and errors in Java. The Throwable class has two subclasses: Exception and Error.

• Exception is the superclass of all checked exceptions in Java. Checked exceptions are exceptions that must be caught or declared in the method signature.
• RuntimeException is the superclass of all unchecked exceptions in Java, a subclass of Exception. Unchecked exceptions are exceptions that do not need to be caught or declared in the method signature.

When catching exceptions, the order of the catch blocks is important. You should catch the most specific exceptions first and the most general exceptions last, as catch blocks traverse the exception hierarchy from top to bottom.

Example

The following is an example of catching exceptions in Java:

try {
    // code that may throw an exception
} catch (ArithmeticException e) {
    // code to handle the ArithmeticException
} catch (Exception e) {
    // code to handle any other exceptions
}

Checked vs. Unchecked Exceptions

Checked exceptions are exceptions that must be caught or declared in the method signature. They are subclasses of Exception (but not RuntimeException).

Unchecked exceptions are exceptions that do not need to be caught or declared in the method signature. They include subclasses of RuntimeException and Error.

Example

The following is an example of a checked exception:

public void readFile() throws IOException {
    // code that may throw an IOException
}

The following is an example of an unchecked exception:

public void divide(int a, int b) {
    if (b == 0) {
        throw new ArithmeticException("Division by zero");
    }
}

Source

The existing course note was retained and normalized during the merge.

Related: Topic index.