Built-in Exceptions in Java

Exceptions that are already available in Java libraries are referred to as built-in exception. These exceptions are able to define the error situation so that we can understand the reason of getting this error.

Types of Built-in Exceptions

Built-in exceptions are of two types:

• Checked Exception
• Unchecked Exception

Checked Exceptions

Checked exceptions are called compile-time exceptions because these exceptions are checked at compile-time by the compiler. The compiler ensures whether the programmer handles the exception or not. The programmer should have to handle the exception; otherwise, the system will show a compilation error.

List of Checked Exceptions

1. ClassNotFoundException: It is thrown when a class cannot be found at runtime.
2. InterruptedException: It occurs when a thread is interrupted while waiting or sleeping.
3. IOException: It signals an I/O operation failure, like reading a missing file.
4. NoSuchMethodException: Raised when a requested method does not exist in a class.
5. CloneNotSupportedException: It is thrown when an object does not support cloning.
6. FileNotFoundException: It occurs when an attempt to open a nonexistent file fails.
7. IllegalAccessException: It raised when access to a class or method is denied.
8. InstantiationException: It is thrown when an attempt to instantiate an abstract class fails.
9. NoSuchFieldException: It occurs when a requested field does not exist in a class.
10. SQLException: It represents errors related to database access and SQL operations.

Example of Checked Exception

Output:

Main.java:5: error: unreported exception FileNotFoundException; must be caught or declared to be thrown file_data = new FileInputStream("C:/Users/Desktop/Hello.txt"); ^ Main.java:7: error: unreported exception IOException; must be caught or declared to be thrown while(( m = file_data.read() ) != -1) { ^ Main.java:10: error: unreported exception IOException; must be caught or declared to be thrown file_data.close(); ^ 3 errors 

In the above code, we are trying to read the Hello.txt file to display its data on the console. When we execute the above program, we get the following exception:

1. The FileInputStream(File filename) constructor throws the FileNotFoundException, which is a checked exception.
2. The read() method of the FileInputStream class throws the IOException.
3. The close() method also throws the IOException.

Handling the Checked Exceptions

There are basically two ways through which we can handle these exceptions.

• Using throws Keyword
• Using try-catch block

Using the throws Keyword

The exceptions occur in the main() method. We can get rid of these compilation errors by declaring the exception in the main() method using the throws keyword. We only declare the IOException, not the FileNotFoundException, because of the child-parent relationship. The IOException class is the parent class of the FileNotFoundException class, so IOException automatically handles this exception. We will declare the exception in the following way:

When we compile and run the above code by handling the IOException using the throws keyword, we get the following output:

Hello Java

Using try-catch Block

We can also handle this exception by using the try-catch block. However, the way we have used above is not correct. We have to give a meaningful message for each exception because it would be easy to understand the error. We will use the try-catch block in the following way:

Output:

File Not Found! Exception in thread "main" java.lang.NullPointerException: Cannot invoke "java.io.FileInputStream.read()" because "<local1>" is null	at Main.main(Main.java:12) 

We will see a proper error message, "File Not Found!" on the console because there is no Hello.txt file at that location. We get the following message on the console.

Unchecked Exceptions

The unchecked exceptions are just the opposite of the checked exceptions. It is also known as a run-time exception. The compiler will not check these exceptions at compile time. In simple words, if a program throws an unchecked exception, and even if we did not handle or declare it, the program would not give a compilation error. Usually, it occurs when the user provides bad data during the interaction with the program.

Note: The RuntimeException class is able to resolve all the unchecked exceptions because of the child-parent relationship.

List of Unchecked Exceptions

1. ArithmeticException: It is thrown when an exceptional arithmetic condition occurs, such as division by zero.
2. ArrayIndexOutOfBoundsException: It is thrown when trying to access an array element with an illegal index.
3. ArrayStoreException: It is thrown when an attempt is made to store an element of the wrong type into an array.
4. NullPointerException: It is thrown when attempting to use a null reference.
5. IllegalStateException: It is thrown when a method is called at an illegal or inappropriate time.
6. ClassCastException: It is thrown when attempting to cast an object to a class of which it is not an instance.
7. IllegalThreadStateException: It is thrown when a method is called at an illegal or inappropriate time.
8. IllegalArgumentException: It is thrown when a method receives an argument formatted differently than expected.
9. NumberFormatException: It is thrown when attempting to convert a string to a numeric type, but the string does not have an appropriate format.
10. UnsupportedOperationException: It is thrown when an operation is not supported.

Example of Unchecked Exceptions

ArithmeticException: Divide by Zero

Output:

Runtime Error: Exception in thread "main" java.lang.ArithmeticException: / by zero	at Main.main(Main.java:7) 

In the above program, we have divided 35 by 0. The code would be compiled successfully, but it will throw an ArithmeticException error at runtime. Dividing a number by 0 throws the divide by zero exception, which is an unchecked exception.

Let's see another example of an unchecked exception.

Example of ArrayIndexOutOfBoundsException

Output:

Runtime Error: Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 7 out of bounds for length 6	at Main.main(Main.java:6) 

In the above code, we are trying to get the element located at position 7, but the length of the array is 6. The code compiles successfully, but throws the ArrayIndexOutOfBoundsException at runtime.

Handling Unchecked Exceptions

Unchecked exceptions in Java are runtime exceptions that aren't required to be caught or declared in the method signature. They typically indicate programming errors, like NullPointerException, ArrayIndexOutOfBoundsException, or IllegalArgumentException.

• Validate Inputs: Prevent exceptions like IllegalArgumentException by checking inputs before using them.
• Use Try-Catch Blocks: Handle specific cases where an unchecked exception might occur.
• Perform Defensive Programming: Always check for null references or ensure safe array access.
• Logging and Debugging: Always log exceptions to analyze issues effectively.

Differences Between Checked and Unchecked Exceptions

Bugs or errors that we do not want and restrict the normal execution of the programs are referred to as exceptions.

Java Checked and Unchecked Exceptions MCQs

1. Which of the following is a checked exception?

1. IOException
2. NumberFormatException
3. NullPointerException
4. IllegalArgumentException

2. Which of the following is an unchecked exception?

1. NoSuchMethodException
2. NumberFormatException
3. NoSuchFieldException
4. ClassNotFoundException

3. Which of the following exceptions that are not required to be caught or declared in the method signature?

1. NoSuchFieldException
2. ClassNotFoundException
3. ArrayIndexOutOfBoundsException
4. NoSuchMethodException

4. How can we handle checked exceptions?

1. Using throws Keyword
2. Using try-catch Block
3. Using throw Keyword
4. 1 and 2 Only

5. Which of the following class is the parent class for all the exceptions and errors?

1. Throwable
2. Exception
3. Error
4. Object