Types of Exceptions in Java with Examples

In Java, an exception is an event that occurs during the execution of a program and disrupts the normal flow of the program's instructions. Bugs or errors that we don't want and restrict our program's normal execution of code are referred to as exceptions. In this section, we will focus on the types of exceptions in Java and the differences between the two.

Types of Exceptions

Exceptions can be categorized in two ways:

1. Built-in Exceptions
   • Checked Exception
   • Unchecked Exception
2. User-Defined Exceptions

Built-in Exception

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. It can be categorized into two broad categories, i.e., checked exceptions and unchecked exception.

Checked Exception

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 has shown a compilation error.

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 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. 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.

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.

User-defined Exception

In Java, we already have some built-in exception classes like ArrayIndexOutOfBoundsException, NullPointerException, and ArithmeticException. These exceptions are restricted to trigger on some predefined conditions. In Java, we can write our exception class by extending the Exception class. We can throw our exception on a particular condition using the throw keyword. For creating a user-defined exception, we should have basic knowledge of the try-catch block and throw keyword.

Let's write a Java program and create user-defined exceptions.

Output:

Exception value = 5

Explanation

In the above code, we have created two classes, i.e., Main and NewException. The Main class has main() method, and the NewException class is a user-defined exception class that extends the Exception class. In the NewException class, we have created a variable x of type integer and assigned a value to it in the constructor. After assigning a value to that variable, we return the exception message.

In the Main class, we have added a try-catch block. In the try block, we throw the exception, i.e., NewException and pass an integer to it. The value will be passed to the NewException class and return a message. We catch that message in the catch block and show it on the console.

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.

Conclusion

ArithmeticException, ArrayIndexOutOfBoundsExceptions, ClassNotFoundExceptions, etc., fall in the category of Built-in Exceptions. Sometimes, the built-in exceptions are not sufficient to explain or describe certain situations. To describe these situations, we have to create our own exceptions by making an exception class as a subclass of the Exception class. These types of exceptions fall into the category of User-Defined Exception.

1. Which of the following is a checked exception in Java?

1. NullPointerException
2. ArithmeticException
3. IOException
4. ArrayIndexOutOfBoundsException

2. What will be the output of the following code?

1. 0
2. Compile-time error
3. Runtime exception: ArithmeticException
4. Infinite loop

3. Which statement is true regarding checked exceptions in Java?

1. They are not required to be caught or declared.
2. They extend the RuntimeException class.
3. The compiler checks them at runtime.
4. They must be either caught or declared to be thrown.

4. What will be the output of the following code?

1. The program reads the file successfully
2. Runtime error: File not found
3. Compile-time error: Unhandled exception type FileNotFoundException
4. No output and no error

5. Identify the type of exception.

What kind of exception is thrown, and how should the code be handled?

1. Checked Exception: Use throws clause
2. Unchecked Exception; Wrap in try-catch (optional)
3. Syntax error; Declare the string
4. Compilation error; str is null