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");
}
}
Try it Yourself >>
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.

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.
The hierarchy is divided into two branches:

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

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 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.
Only the unchecked exceptions are encountered
Errors mainly occur during run-time.
in run-time.
Exceptions can be handled using exception-
Errors are irrecoverable
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.
specifies the code block to be executed if an exception occurs in the try
catch
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.
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 single try-catch block
1. class Main
2. {
3. public static void main(String[] args)
4. {
5. try
6. {
7. // code that generate exception
8. int divideByZero = 5 / 0;
9. System.out.println("Rest of code in try block");
10. }
 11. catch (ArithmeticException e) {
12. System.out.println("ArithmeticException => " + e.getMessage());
13. }
14. }
}
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

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

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 finally is the block in Java finalize is the method in Java
modifier, which is used to apply Exception Handling to execute that is used to perform clean-
restrictions on a class, method, or the important code whether the up processing just before an
variable. exception occurs or not. object is garbage collected.
Finally, the block is always
The final keyword is used with the finalize() method is used with
related to the try-catch block in
classes, methods, and variables. the objects.
exception handling.
It is used with variables, methods, It is with the try-catch block in
Used with objects
and classes. exception handling.
Once declared, the final variable
becomes constant and can't be finalize method performs the
finally block cleans up all the
modified. A sub-class can neither cleaning concerning the object
resources used in the try block
override a final method nor can the before its destruction
final class be inherited.
finally block executes as soon as
finalize method is executed
final method is executed only when the execution of the try-catch
just before the object is
we call it block is completed without
destroyed
depending on the exception
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 Java throws keyword is used in method or
exception inside any block of code or function in function signature to declare an exception that
the program. the method may throw while execution of code
throw keyword can be used to throw both throws keyword can be used only with checked
checked and unchecked exceptions exceptions.
throw is used within the method. throws is used within the method signature
Syntax: throw new exception_class("error Syntax: void method() throws
message"); 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.