Java Built-in Exceptions

Java provides a set of built-in exceptions that handle common error scenarios in programming. Understanding these exceptions is essential for developers to write robust and error-resistant code.

Key Concepts

• Exceptions: Events that disrupt the normal flow of a program, arising from issues like invalid input, file not found, or division by zero.
• Checked vs. Unchecked Exceptions:
  • Checked Exceptions: Must be caught or declared in the method signature, checked at compile-time.
  • Unchecked Exceptions: Do not need to be declared or caught, checked at runtime.

Common Built-in Exceptions

1. ArithmeticException

• Description: Occurs during arithmetic operations, such as division by zero.

Example:

int result = 10 / 0; // This will throw ArithmeticException

2. NullPointerException

• Description: Triggered when trying to use an object reference that has not been initialized.

Example:

String str = null;
System.out.println(str.length()); // This will throw NullPointerException

3. ArrayIndexOutOfBoundsException

• Description: Happens when trying to access an array with an invalid index.

Example:

int[] arr = {1, 2, 3};
int number = arr[3]; // This will throw ArrayIndexOutOfBoundsException

4. ClassCastException

• Description: Occurs when trying to cast an object to a subclass of which it is not an instance.

Example:

Object obj = new Integer(10);
String str = (String) obj; // This will throw ClassCastException

5. NumberFormatException

• Description: Triggered when trying to convert a string that does not have an appropriate format to a numeric type.

Example:

String number = "abc";
int num = Integer.parseInt(number); // This will throw NumberFormatException

Handling Exceptions

To handle exceptions gracefully, Java provides a try-catch block:

try {
    // Code that may throw an exception
} catch (SpecificExceptionType e) {
    // Code to handle the exception
} finally {
    // Code that runs regardless of an exception
}

Example of Exception Handling

try {
    int result = 10 / 0; // May cause ArithmeticException
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero."); // Handling the exception
}

Conclusion

Understanding Java's built-in exceptions is crucial for effective error handling in programs. By utilizing appropriate exception handling mechanisms, programmers can ensure their applications run smoothly and handle unexpected situations gracefully.