07
DecWhat is Exception Handling in Java?: try, catch, throw, finally
Exception Handling in Java
Exception Handling in Java is an effective method for dealing with unwanted and unexpected events during program execution while maintaining the application's usual flow. When learning Java, one must be ready to deal with errors, unexpected inputs, or other exceptions. Java Exception handling is a technique for handling different types of errors, such as FileNotFoundExceptions, IOExceptions, ClassNotFoundExceptions, etc.
In this blog post on Java tutorial, we'll discuss exceptions and their types in Java, exception handling keywords like try, catch, throw, throws, and finally, with examples, exception hierarchy, differences between errors and exceptions, the final, finally, and finalize keywords, etc.
Get certified and land your dream job with our Java Full Stack Developer Certification Training—register now!
What is an Exception in Java?
Exceptions are unwanted events that disrupt the program's execution. Many a time, your program looks error-free after writing the code. But, at the time of execution, some unexpected errors or events or objects come to the surface, and the program prints an error message and stops executing. Such unexpected happenings are called exceptions in Java.
Example of Exception in Java
class ExceptionExample {
public static void main(String args[]) {
System.out.println("Welcome to ScholarHat");
int a = 30;
int b = 0;
System.out.println(a / b);
System.out.println("Welcome to the ScholarHat's Java Programming tutorial.");
System.out.println("Enjoy your learning");
}
}
In the above code, at the 4th line, an integer is divided by 0, which is not possible, and the JVM(Java Virtual Machine) raises an exception. In this case, the programmer does not handle the exception, which will halt the program in between by throwing the exception, and the rest of the lines of code won't be executed.
Read More: Differences between JDK, JRE, and JVM: Java Toolkit |
Output
Welcome to ScholarHat
Exception in thread "main" java.lang.ArithmeticException: / by zero
at ExceptionExample.main(ExceptionExample.java:6)
There are some specific reasons why exceptions occur in Java:
- User’s Invalid Input
- Database Connection Error
- System Failure
- Network Problem
- Security Compromises
- Errors in Code
- Physical Limitations
What is Exception Handling in Java?
Exception Handling is a way of handling errors that occur during runtime and compile time. It maintains your program flow despite runtime errors in the code and, thus, prevents unanticipated crashes. It facilitates troubleshooting by providing error details, cutting down on development time, and improving user happiness.
Exception Hierarchy in Java
Exception and Error are subclasses of Throwable, the hierarchy's base class. Exception, for example, is used for exceptional conditions that user programs should catch. Error, on the other hand, is used by the Java run-time system (JVM) to indicate errors related to the run-time environment (JRE), such as StackOverflowError.
Read More: What is Class in Java? Objects and Classes in Java {Explained} |
The hierarchy is divided into two branches:
- Errors: An error is a severe condition that can occur only at run time and is irrecoverable. It prevents a program from executing and cannot be handled by the programmer. An error belongs to the java.lang.error class.
- Exceptions: A programmer can catch and handle exceptions in his program code. When an exception occurs within a method, an object called the exception object is created. This object contains information about the exception, such as its name and description and the state of the program when the exception occurred.
We'll look at the types of exceptions below:
Types of Exceptions in Java
There are mainly two types of exceptions: user-defined and built-in.
1. Built-in Exceptions
These exceptions are present in Java libraries.
There are two types of built-in exceptions in Java:
1. Checked Exception
Checked exceptions are classes that inherit directly from the Throwable class, with the exception of RuntimeException and Error. Examples include IOException, SQLException, and so on. Checked exceptions are checked at compilation time. They must be either caught by the code or declared in the method signature using the throws keyword.
2. Unchecked Exception
Classes that inherit the RuntimeException class are known as unchecked exceptions. Examples include ArithmeticException, NullPointerException, and ArrayIndexOutOfBoundsException. Unchecked exceptions are not checked at compile-time but rather at runtime by JVM. They do not need to be explicitly caught or declared.
2. User-Defined Exceptions
User-defined exceptions are also known as custom exceptions derived from the Exception class from java.lang package. The user creates these exceptions according to different situations. Such exceptions are handled using five keywords: try, catch, throw, throws, and finally.
We'll learn how to use these keywords in the Exception Handling Keywords in Java section below.
Errors Vs. Exceptions in Java
Errors | Exceptions |
Belongs to the java.lang.Error class | defined in java.lang.Exception package |
Errors are of Unchecked type | Exceptions can be both checked and unchecked. |
Errors mainly occur during run-time. | Only the unchecked exceptions are encountered in run-time. |
Errors are irrecoverable | Exceptions can be handled using exception-handling mechanisms |
Java Exception Handling Keywords
Java consists of five keywords to handle various kinds of custom exceptions. They are:
Keyword | Description |
try | The "try" keyword specifies an exception block. |
catch | specifies the code block to be executed if an exception occurs in the try block. |
finally | the finally block will always be executed whether an exception occurs or not |
throw | the "throw" keyword triggers an exception |
throws | The "throws" keyword declares an exception. |
1. try
- A try block consists of all the doubtful statements that can throw exceptions.
- A try block cannot be executed on itself; it requires at least one catch block or finally block.
- If an exception occurs, the control flows from the try-to-catch block.
- When an exception occurs in a try block, the appropriate exception object is redirected to the catch block. This catch block handles the exception according to its statements and continues the execution.
Syntax
try
{
//Doubtful Statements.
}
2. catch
- The catch block handles the exception raised in the try block.
- The catch block or blocks follow every try block.
- The catch block catches the thrown exception as its parameter and executes the statements inside it.
- The declared exception must be the parent class exception, the generated exception type in the exception class hierarchy, or a user-defined exception.
Syntax
try
{
// code
}
catch(Exception e)
{
// code to handle exceptions
}
Examples IIlustrating Implementation of try-catch blocks for Java Exception Handling in Java Online Compiler
- single try-catch block
class Main { public static void main(String[] args) { try { // code that generate exception int divideByZero = 5 / 0; System.out.println("Rest of code in try block"); } catch (ArithmeticException e) { System.out.println("ArithmeticException => " + e.getMessage()); } } }
In the above code, we have put the "int divideByZero=5/0" in the try block because this statement must not be executed if the denominator is 0. If the denominator is 0, the statements after this statement in the try block are skipped. The catch block catches the thrown exception as its parameter and executes the statements inside it.
Output
ArithmeticException => / by zero
- Multiple catch Blocks
We can use multiple catch statements for different kinds of exceptions that can occur from a single block of code in the try block.
Syntax
try { // code to check exceptions } catch (exception1) { // code to handle the exception } catch (exception2) { // code to handle the exception } . . . catch (exception n) { // code to handle the exception }
Example
public class MultipleCatchBlock { public static void main(String[] args) { try { int x[] = new int[5]; x[5] = 40 / 0; } catch (ArithmeticException e) { System.out.println("Arithmetic Exception occurs"); } catch (ArrayIndexOutOfBoundsException e) { System.out.println("ArrayIndexOutOfBounds Exception occurs"); } catch (Exception e) { System.out.println("Parent Exception occurs"); } System.out.println("The program ends here"); } }
Here, our program matches the type of exception that occurred in the try block with the catch statements. If the exception that occurred matches any of the usual catch statements, that particular catch block gets executed.
Output
Arithmetic Exception occurs The program ends here
- Nested try-catch
Here, we have a try-catch block inside a nested try block.
class NestingTry { public static void main(String args[]) { //main try-block try { //try-block2 try { //try-block3 try { int arr[] = { 10, 20, 30, 40 }; System.out.println(arr[10]); } catch (ArithmeticException e) { System.out.print("Arithmetic Exception"); System.out.println(" handled in try-block3"); } } catch (ArithmeticException e) { System.out.print("Arithmetic Exception"); System.out.println(" handled in try-block2"); } } catch (ArithmeticException e3) { System.out.print("Arithmetic Exception"); System.out.println(" handled in main try-block"); } catch (ArrayIndexOutOfBoundsException e4) { System.out.print("ArrayIndexOutOfBoundsException"); System.out.println(" handled in main try-block"); } catch (Exception e5) { System.out.print("Exception"); System.out.println(" handled in main try-block"); } } }
In the above code, the ArrayIndexOutOfBoundsException occurred in the grandchild try-block3. Since try-block3 is not handling this exception, the control then gets transferred to the parent try-block2. Since try-block2 also does not handle that exception, the control gets transferred to the main try-block, where it finds the appropriate catch block for an exception.
Output
ArrayIndexOutOfBoundsException handled in main try-block
3. finally
The finally block in Java always executes even if there are no exceptions. This is an optional block. It is used to execute important statements such as closing statements, releasing resources, and releasing memory. There could be one final block for every try block. This finally block executes after the try...catch block.
Syntax
try
{
//code
}
catch (ExceptionType1 e1)
{
// catch block
}
finally
{
// finally block always executes
}
Example of Java Exception Handling using finally block in Java Playground
class Main
{
public static void main(String[] args)
{
try
{
// code that generates exception
int divideByZero = 5 / 0;
}
catch (ArithmeticException e)
{
System.out.println("ArithmeticException => " + e.getMessage());
}
finally
{
System.out.println("This is the finally block");
}
}
}
In this Java example, trying to divide by zero results in an ArithmeticException that is caught and accompanied by an error message. The "finally" block also always runs, printing "This is the finally block" whether or not an exception was raised.
Output
ArithmeticException => / by zero
This is the finally block
final Vs. finally Vs. finalize in Java
final | finally | finalize |
final is a keyword and access modifier, which is used to apply restrictions on a class, method, or variable. | finally is the block in Java Exception Handling to execute the important code whether the exception occurs or not. | finalize is the method in Java that is used to perform clean-up processing just before an object is garbage collected. |
The final keyword is used with the classes, methods, and variables. | Finally, the block is always related to the try-catch block in exception handling. | finalize() method is used with the objects. |
It is used with variables, methods, and classes. | It is with the try-catch block in exception handling. | Used with objects |
Once declared, the final variable becomes constant and can't be modified. A sub-class can neither override a final method nor can the final class be inherited. | finally block cleans up all the resources used in the try block | finalize method performs the cleaning concerning the object before its destruction |
final method is executed only when we call it | finally block executes as soon as the execution of the try-catch block is completed without depending on the exception | finalize method is executed just before the object is destroyed |
4. throw
- The throw keyword is used to explicitly throw a checked or an unchecked exception.
- The exception that is thrown needs to be of type Throwable or a subclass of Throwable.
- We can also define our own set of conditions for which we can throw an exception explicitly using the throw keyword.
- The program's execution flow stops immediately after the throw statement is executed, and the nearest try block is checked to see if it has a catch statement that matches the type of exception.
Syntax
throw new exception_class("error message");
Example of Exception Handling using Java throw
class ThrowExample {
// Method to check if a number is negative
public static void checkNumber(int number) {
if (number < 0) {
// Throwing an IllegalArgumentException if the number is negative
throw new IllegalArgumentException("Number cannot be negative");
} else {
System.out.println("Number is " + number);
}
}
public static void main(String[] args) {
try {
// Trying to check a negative number
checkNumber(-5);
} catch (IllegalArgumentException e) {
// Handling the thrown exception
System.out.println("Caught an exception: " + e.getMessage());
}
}
}
In the main method, the exception is captured and handled using a try-catch block, showing the exception message if the input is negative. This Java class, ThrowExample, contains a method checkNumber that throws an IllegalArgumentException if the input number is negative.
Output
Caught an exception: Number cannot be negative
5. throws
The throws keyword is used in the method signature to indicate that a method in Java can throw particular exceptions. This notifies the method that it must manage or propagate these exceptions to the caller.
import java.io.IOException;
public class ThrowsExample {
public static void main(String[] args) {
try {
methodWithException();
} catch (IOException e) {
System.out.println("Caught IOException: " + e.getMessage());
}
}
public static void methodWithException() throws IOException {
// Simulate an IOException
throw new IOException("This is an IOException");
}
}
In the above code, the method methodWithException is declared with throws IOException, indicating that it may throw an IOException. The catch block catches the IOException in the main method.
Output
Caught IOException: This is an IOException
throw Vs. throws in Java
throw | throws |
The throw keyword is used to explicitly throw an exception inside any block of code or function in the program. | Java throws keyword is used in method or function signature to declare an exception that the method may throw while execution of code |
throw keyword can be used to throw both checked and unchecked exceptions | throws keyword can be used only with checked exceptions. |
throw is used within the method. | throws is used within the method signature |
Syntax: throw new exception_class("error message"); | Syntax: void method() throws ArithmeticException |
We can throw only one exception at a time | We can declare multiple exceptions using the throws keyword that the method can throw |
Common Scenarios of Java Exceptions
1. ArithmeticException
This exception is raised by JVM when the programmer tries to perform any arithmetic operation that is not possible in mathematics. One of the frequently occurring arithmetic exceptions is when we divide any number with zero.
int a=30/0; //ArithmeticException
2. NullPointerException
This occurs when a user tries to access a variable that stores null values. For example, if a variable stores a null value and the user tries to perform any operation on that variable, a NullPointerException will be thrown.
String s=null;
System.out.println(s.length());//NullPointerException
3. NumberFormatException
If the formatting of any variable or number is mismatched, it may result in a NumberFormatException.
String s="ScholarHat";
int i=Integer.parseInt(s);//NumberFormatException
4. ArrayIndexOutOfBoundsException
When an array exceeds its size, the ArrayIndexOutOfBoundsException occurs.
int a[]=new int[6];
a[10]=80; //ArrayIndexOutOfBoundsException
5. StringIndexOutOfBoundsException
It is the same as ArrayIndexOutOfBoundsException but it is for strings instead of arrays. Here if the length of a string is less than what we are trying to access there occurs the StringIndexOutOfBoundsException.
String s = "I am learning Java on ScholarHat.";
System.out.println("String length is:" + s.length());
System.out.println("Length of substring is:" + s1.substring(40)); //StringIndexOutOfBoundsException
Advantages of Exception Handling in Java
- It helps to find which type of errors occur.
- It helps to complete the program executions.
- It allows the program to run continuously without any disruption.
- It provides the ability to catch the specific exception that occurred in the program.
- It also helps the developers to write cleaner code and learn how to handle exceptions.
You can also read: |
Go through the following Java Interview Questions articles: |
Summary
It is incorrect to use exceptions as an error recovery technique. The keywords "try," "catch," "finally," "throw," and "throws" are used to control them all. While adding complexity to the program, exception handling also makes the code more understandable to the developer. Exception handling makes it simple to identify errors in the code and contributes to the writing of cleaner code, which improves the efficiency of programs and applications. To increase your knowledge of Java, you can also take our Java Full Stack Course.