Java Exception Handling Tutorial

An exception is an event that occurs during the execution of a program that disrupts its normal flow. Exceptions can be caused by various factors, such as invalid user input, file not found, or network issues.

• Checked Exceptions: Exceptions that are checked at compile-time (e.g., IOException, SQLException).
• Unchecked Exceptions: Exceptions that are checked at runtime (e.g., NullPointerException, ArithmeticException).
• Errors: Serious issues that are not meant to be caught (e.g., OutOfMemoryError, StackOverflowError).

The try-catch block is used to catch and handle exceptions. The try block contains the code that might throw an exception, and the catch block contains the code to handle the exception.

• Syntax:
  Edit Copy

  try {
      // Code that might throw an exception
  } catch (ExceptionType e) {
      // Code to handle the exception
  }

• Example:
  Edit Copy

  public class Main {
      public static void main(String[] args) {
          try {
              int result = 10 / 0; // This will throw an ArithmeticException
          } catch (ArithmeticException e) {
              System.out.println("Caught an exception: " + e.getMessage());
          }
      }
  }

You can use multiple catch blocks to handle different types of exceptions separately.

• Syntax:
  Edit Copy

  try {
      // Code that might throw an exception
  } catch (ExceptionType1 e) {
      // Handle ExceptionType1
  } catch (ExceptionType2 e) {
      // Handle ExceptionType2
  }

• Example:
  Edit Copy

  public class Main {
      public static void main(String[] args) {
          try {
              int[] numbers = {1, 2, 3};
              System.out.println(numbers[5]); // This will throw an ArrayIndexOutOfBoundsException
          } catch (ArithmeticException e) {
              System.out.println("Caught an arithmetic exception: " + e.getMessage());
          } catch (ArrayIndexOutOfBoundsException e) {
              System.out.println("Caught an array index out of bounds exception: " + e.getMessage());
          }
      }
  }

The finally block is used to execute code regardless of whether an exception is thrown or not. It is often used for cleanup activities, such as closing files or releasing resources.

• Syntax:
  Edit Copy

  try {
      // Code that might throw an exception
  } catch (ExceptionType e) {
      // Handle the exception
  } finally {
      // Code to be executed regardless of an exception
  }

• Example:
  Edit Copy

  public class Main {
      public static void main(String[] args) {
          try {
              int result = 10 / 0; // This will throw an ArithmeticException
          } catch (ArithmeticException e) {
              System.out.println("Caught an exception: " + e.getMessage());
          } finally {
              System.out.println("This will always be executed.");
          }
      }
  }

You can create your own exception classes by extending the Exception class. Custom exceptions are useful for handling specific errors in your application.

• Example:
  Edit Copy

  // Custom exception class
  class InvalidAgeException extends Exception {
      public InvalidAgeException(String message) {
          super(message);
      }
  }
  
  public class Main {
      static void validateAge(int age) throws InvalidAgeException {
          if (age < 18) {
              throw new InvalidAgeException("Age must be 18 or older.");
          } else {
              System.out.println("Age is valid.");
          }
      }
  
      public static void main(String[] args) {
          try {
              validateAge(15); // This will throw an InvalidAgeException
          } catch (InvalidAgeException e) {
              System.out.println("Caught an exception: " + e.getMessage());
          }
      }
  }