Scribd
Upload
45 views

Catching and Handling Exceptions

Java uses try, catch, and finally blocks to handle exceptions. Code that could generate an exception is placed in the try block. Catch blocks are used to handle specific exception types, and a finally block, if present, will always execute regardless of whether an exception occurred or was handled.

Uploaded by

Altamash
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
45 views

Catching and Handling Exceptions

Java uses try, catch, and finally blocks to handle exceptions. Code that could generate an exception is placed in the try block. Catch blocks are used to handle specific exception types, and a finally block, if present, will always execute regardless of whether an exception occurred or was handled.

Uploaded by

Altamash
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 5

Catching and handling exceptions

In Java, we use the exception handler


components  try ,  catch  and  finally  blocks to handle exceptions.
To catch and handle an exception, we place the  try...catch...finally  block
around the code that might generate an exception. The  finally  block is
optional.
The syntax for  try...catch...finally  is:

try {
// code
} catch (ExceptionType e) {
// catch block
} finally {
// finally block
}

Java try...catch block


The code that might generate an exception is placed in the  try  block.
Every  try  block should be immediately followed by
the  catch  or  finally  block. When an exception occurs, it is caught by
the  catch  block that immediately follows it.
catch  blocks cannot be used alone and must always be preceded by
a  try  block.
Example 1: try...catch blocks

class Main {
public static void main(String[] args) {

try {
int divideByZero = 5 / 0;
System.out.println("Rest of code in try block");
} catch (ArithmeticException e) {
System.out.println("ArithmeticException => " + e.getMessage());
}

}
}

Output

ArithmeticException => / by zero

In the example,

 We have divided a number by 0 inside the try block. This produces


an  ArithmeticException .
 When the exception occurs, the program skips the rest of the code in
the  try  block.
 Here, we have created a catch block to handle  ArithmeticException .
Hence, the statements inside the  catch  block are executed.
If none of the statements in the  try  block generates an exception,
the  catch  block is skipped.

Multiple Catch blocks


For each  try  block, there can be zero or more  catch  blocks.
The argument type of each  catch  block indicates the type of exception that
can be handled by it. Multiple  catch  blocks allow us to handle each
exception differently.
Example 2: Multiple catch blocks

class ListOfNumbers {
public int[] arrayOfNumbers = new int[10];

public void writeList() {

try {
arrayOfNumbers[10] = 11;
} catch (NumberFormatException e1) {
System.out.println("NumberFormatException => " + e1.getMessage());
} catch (IndexOutOfBoundsException e2) {
System.out.println("IndexOutOfBoundsException => " + e2.getMessage());
}

}
}

class Main {
public static void main(String[] args) {
ListOfNumbers list = new ListOfNumbers();
list.writeList();
}
}

Output

IndexOutOfBoundsException => Index 10 out of bounds for length 10

In this example, we have declared an array of integers  arrayOfNumbers  of


size 10.
We know that an array index always starts from 0. So, when we try to
assign a value to index 10, an  IndexOutOfBoundsException  occurs because the
array bounds for  arrayOfNumbers  is 0 to 9.
When an exception occurs in the  try  block,
 The exception is thrown to the first  catch  block. The first  catch  block
does not handle an  IndexOutOfBoundsException , so it is passed to the
next  catch  block.
 The second  catch  block in the above example is the appropriate
exception handler because it handles an  IndexOutOfBoundsException . Hence,
it is executed.
Java finally block
For each  try  block, there can be only one  finally  block.
The  finally  block is optional. However, if defined, it is always executed
(even if the exception doesn't occur).
If an exception occurs, it is executed after the  try...catch  block. If no
exception occurs, it is executed after the  try  block.
The basic syntax of  finally  block is:

try {
//code
} catch (ExceptionType1 e1) {
// catch block
} catch (ExceptionType1 e2) {
// catch block
} finally {
// finally block always executes
}

Example 3: finally block

class Main {
public static void main(String[] args) {
try {
int divideByZero = 5 / 0;
} catch (ArithmeticException e) {
System.out.println("ArithmeticException => " + e.getMessage());
} finally {
System.out.println("Finally block is always executed");
}
}
}

Output

ArithmeticException => / by zero


Finally block is always executed

In this example, we have divided a number by 0. This throws


an  ArithmeticException  which is caught by the  catch  block. The  finally  block
always executes.
Having a  finally  block is considered a good practice. It is because it
includes important cleanup code such as:
 code that might have been accidentally skipped
by  return ,  continue  or  break  statements
 closing a file or connection

You might also like