In Java, exceptions are events that disrupt the normal flow of a program’s execution. When an exception occurs, Java provides a mechanism to catch and handle it, ensuring that the program doesn’t abruptly terminate.
An exception is an event that occurs during the execution of a program that disrupts its normal flow. In Java, exceptions are represented by objects that are instances of classes derived from the Throwable class. Exceptions can either be checked or unchecked, and understanding their difference is key to handling them properly.
Java exceptions are broadly categorized into two types:
- Checked Exceptions
- Unchecked Exceptions
Checked Exceptions
Checked exceptions are exceptions that are explicitly checked at compile time. If a method can throw a checked exception, the programmer is required to either handle it with a try-catch block or declare it in the method signature using the throws keyword. These exceptions typically represent issues that can be anticipated and recovered from.
Checked exceptions enforce a contract that developers must either deal with or explicitly declare the exception. This helps to prevent runtime errors by addressing potential problems during compilation, improving the program’s reliability.
IOException
This exception occurs when there are issues with input or output operations, such as when reading from a file or network connection. It is a checked exception because it’s often expected and should be handled by the programmer.
|
1 2 3 4 5 |
try { FileReader file = new FileReader("nonexistentfile.txt"); } catch (IOException e) { System.out.println("IOException: " + e.getMessage()); } |
SQLException
This exception is thrown when there are errors related to database access. For example, when trying to execute a query on a database that fails due to syntax issues or connection problems.
|
1 2 3 4 5 |
try { Connection conn = DriverManager.getConnection(dbURL, user, password); } catch (SQLException e) { System.out.println("SQLException: " + e.getMessage()); } |
ClassNotFoundException
This exception occurs when the Java runtime system cannot find the class being referenced by the program. It is commonly seen when dynamically loading classes using reflection or class loaders.
|
1 2 3 4 5 |
try { Class.forName("com.example.MyClass"); } catch (ClassNotFoundException e) { System.out.println("ClassNotFoundException: " + e.getMessage()); } |
Unchecked Exceptions
Unchecked exceptions, also known as runtime exceptions, are not checked at compile time. These exceptions inherit from the RuntimeException class. They typically arise due to programming errors, and they are often caused by incorrect logic, such as accessing an array element outside its bounds or attempting to divide by zero.
Unchecked exceptions are generally used to indicate bugs in the program. Since they are not mandatory to handle, they allow the developer to focus on addressing logical issues. However, it’s important to ensure that they are fixed, as they often lead to program crashes. Unlike checked exceptions, developers are not required to handle or declare unchecked exceptions. These are generally considered programming errors that the developer should aim to fix.
NullPointerException
This is one of the most common runtime exceptions in Java. It occurs when an application attempts to use an object reference that is set to null.
|
1 2 |
String text = null; System.out.println(text.length()); // NullPointerException |
ArrayIndexOutOfBoundsException
This exception occurs when an array is accessed with an invalid index (e.g., an index less than 0 or greater than the array’s length).
|
1 2 |
int[] arr = new int[3]; System.out.println(arr[5]); // ArrayIndexOutOfBoundsException |
ArithmeticException
This exception occurs when an illegal arithmetic operation is performed, such as division by zero.
|
1 |
int result = 10 / 0; // ArithmeticException |
ClassCastException
This exception occurs when an object is cast to a type it is not an instance of. This can happen, for example, when casting an object to a subclass without checking its type.
|
1 2 |
Object obj = new String("Hello"); Integer num = (Integer) obj; // ClassCastException |
