Exception Handling Keywords in Java

Exception handling is a crucial aspect of writing robust Java applications, ensuring that programs can gracefully handle runtime errors without crashing. In Java, there are 5 exception handling keywords such as try, catch, finally, throw, and throws. These keywords allow developers to manage errors efficiently, define custom exceptions, and maintain code stability. In this blog post, we will explore these keywords in detail, understand their use cases, and demonstrate their implementation with practical examples.

5 Exception Handling Keywords in Java

try

The try keyword is used to enclose a block of code that may throw an exception. If an exception is thrown inside the try block, the catch block will be executed.

try {
  // Code that may throw an exception
} catch (Exception e) {
  // Handle the exception
}

catch

The catch keyword is used to catch an exception that is thrown by the try block. The catch block must be followed by a parameter that specifies the type of exception that it can handle.

try {
  // Code that may throw an exception
} catch (ArithmeticException e) {
  // Handle the ArithmeticException exception
}

finally

The finally keyword is used to execute a block of code regardless of whether or not an exception is thrown. The finally block is often used to close resources, such as files and sockets.

try {
  // Code that may throw an exception
} catch (Exception e) {
  // Handle the exception
} finally {
  // Close resources
}

Example to show try, catch, and finally keywords used together.

public class ExceptionHandlingDemo {

  public static void main(String[] args) {
    try {

      int x = 10;
      int y = 0;
      // The following will throw an ArithmeticException exception
      System.out.println(x / y);
    } catch (ArithmeticException e) {

      System.out.println("Cannot divide by zero");
    } finally {

      System.out.println("Closing resources");
    }
  }
}

When we run this code, it will print the following output:

Cannot divide by zero
Closing resources

throw

The throw keyword is used to throw an exception. The throw keyword must be followed by an object of the Exception class or a subclass of the Exception class.

public void divideByZero() throws ArithmeticException {
  int x = 10;
  int y = 0;

  // Throw an ArithmeticException exception if y is 0
  if (y == 0) {
    throw new ArithmeticException("Cannot divide by zero");
  }
}

throws

The throws keyword is used to declare that a method may throw an exception. The throws keyword must be followed by a list of the exceptions that the method may throw.

public int divide(int x, int y) throws ArithmeticException {
  // Code that may throw an ArithmeticException exception

  return x / y;
}

Conclusion

Effective exception handling is essential for building reliable Java applications. By using exception handling keywords in Java like try, catch, finally, throw, and throws, developers can manage errors gracefully and ensure smooth program execution. Mastering these concepts will help you write more robust and maintainable Java code.

FAQs