The
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[]];
}
}
}
5 block in Java is used to handle exceptions and prevents the abnormal termination of the program.Here's the syntax of a
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[]];
}
}
}
5 block in Java.try{
// code
}
catch[exception] {
// code
}
The
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[]];
}
}
}
7 block includes the code that might generate an exception.The
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[]];
}
}
}
8 block includes the code that is executed when there occurs an exception inside the 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[]];
}
}
}
7 block.Example: Java try...catch block
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 above example, notice the line,
int divideByZero = 5 / 0;
Here, we are trying to divide a number by zero. In this case, an exception occurs. Hence, we have enclosed this code inside the
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[]];
}
}
}
7 block.When the program encounters this code,
ArithmeticException => / by zero1 occurs. And, the exception is caught by the
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[]];
}
}
}
8 block and executes the code inside the 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[]];
}
}
}
8 block.The
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[]];
}
}
}
8 block is only executed if there exists an exception inside the 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[]];
}
}
}
7 block.Note: In Java, we can use a
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[]];
}
}
}
7 block without a 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[]];
}
}
}
8 block. However, we cannot use a 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[]];
}
}
}
8 block without a 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[]];
}
}
}
7 block.Java try...finally block
We can also use the
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[]];
}
}
}
7 block along with a finally block.In this case, the finally block is always executed whether there is an exception inside the try block or not.
Example: Java try...finally block
class Main {
public static void main[String[] args] {
try {
int divideByZero = 5 / 0;
}
finally {
System.out.println["Finally block is always executed"];
}
}
}
Output
Finally block is always executed Exception in thread "main" java.lang.ArithmeticException: / by zero at Main.main[Main.java:4]
In the above example, we have used the
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[]];
}
}
}
7 block along with the int divideByZero = 5 / 0;
2 block. We can see that the code inside the 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[]];
}
}
}
7 block is causing an exception.However, the code inside the
int divideByZero = 5 / 0;
2 block is executed irrespective of the exception.In Java, we can also use the finally block after the
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[]];
}
}
}
5 block. For example,import java.io.*;
class ListOfNumbers {
// create an integer array
private int[] list = {5, 6, 8, 9, 2};
// method to write data from array to a fila
public void writeList[] {
PrintWriter out = null;
try {
System.out.println["Entering try statement"];
// creating a new file OutputFile.txt
out = new PrintWriter[new FileWriter["OutputFile.txt"]];
// writing values from list array to Output.txt
for [int i = 0; i < 7; i++] {
out.println["Value at: " + i + " = " + list[i]];
}
}
catch [Exception e] {
System.out.println["Exception => " + e.getMessage[]];
}
finally {
// checking if PrintWriter has been opened
if [out != null] {
System.out.println["Closing PrintWriter"];
// close PrintWriter
out.close[];
}
else {
System.out.println["PrintWriter not open"];
}
}
}
}
class Main {
public static void main[String[] args] {
ListOfNumbers list = new ListOfNumbers[];
list.writeList[];
}
}
Output
Entering try statement Exception => Index 5 out of bounds for length 5 Closing PrintWriter
In the above example, we have created an array named list and a file named output.txt. Here, we are trying to read data from the array and storing to the file.
Notice the code,
for [int i = 0; i < 7; i++] {
out.println["Value at: " + i + " = " + list[i]];
}
Here, the size of the array is
int divideByZero = 5 / 0;
6 and the last element of the array is at int divideByZero = 5 / 0;
7. However, we are trying to access elements at int divideByZero = 5 / 0;
8 and int divideByZero = 5 / 0;
9.Hence, the code generates an exception that is caught by the catch block.
Since the
int divideByZero = 5 / 0;
2 block is always executed, we have included code to close the class Main {
public static void main[String[] args] {
try {
int divideByZero = 5 / 0;
}
finally {
System.out.println["Finally block is always executed"];
}
}
}
1 inside the finally block.It is a good practice to use finally block to include important cleanup code like closing a file or connection.
Note: There are some cases when a
int divideByZero = 5 / 0;
2 block does not execute:- Use of
3 methodclass Main { public static void main[String[] args] { try { int divideByZero = 5 / 0; } finally { System.out.println["Finally block is always executed"]; } } }
- An exception occurs in the
2 blockint divideByZero = 5 / 0;
- The death of a thread
For each
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[]];
}
}
}
7 block, there can be zero or more 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[]];
}
}
}
8 blocks. Multiple 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[]];
}
}
}
8 blocks allow us to handle each exception differently.The argument type of each
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[]];
}
}
}
8 block indicates the type of exception that can be handled by it. For example,class ListOfNumbers {
public int[] arr = new int[10];
public void writeList[] {
try {
arr[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
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[]];
}
}
}
0In this example, we have created an integer array named
class Main {
public static void main[String[] args] {
try {
int divideByZero = 5 / 0;
}
finally {
System.out.println["Finally block is always executed"];
}
}
}
9 of size 10.Since the array index starts from 0, the last element of the array is at
Finally block is always executed Exception in thread "main" java.lang.ArithmeticException: / by zero at Main.main[Main.java:4]0. Notice the statement,
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[]];
}
}
}
1Here, we are trying to assign a value to the index 10. Hence,
Finally block is always executed Exception in thread "main" java.lang.ArithmeticException: / by zero at Main.main[Main.java:4]1 occurs.
When an exception occurs in the
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[]];
}
}
}
7 block,- The exception is thrown to the first
8 block. The firstclass 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[]]; } } }
8 block does not handle anclass 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[]]; } } }
Finally block is always executed Exception in thread "main" java.lang.ArithmeticException: / by zero at Main.main[Main.java:4]
5, so it is passed to the next
8 block.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[]]; } } }
- The second
8 block in the above example is the appropriate exception handler because it handles anclass 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[]]; } } }
Finally block is always executed Exception in thread "main" java.lang.ArithmeticException: / by zero at Main.main[Main.java:4]
5. Hence, it is executed.
Catching Multiple Exceptions
From Java SE 7 and later, we can now catch more than one type of exception with one
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[]];
}
}
}
8 block.This reduces code duplication and increases code simplicity and efficiency.
Each exception type that can be handled by the
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[]];
}
}
}
8 block is separated using a vertical bar import java.io.*;
class ListOfNumbers {
// create an integer array
private int[] list = {5, 6, 8, 9, 2};
// method to write data from array to a fila
public void writeList[] {
PrintWriter out = null;
try {
System.out.println["Entering try statement"];
// creating a new file OutputFile.txt
out = new PrintWriter[new FileWriter["OutputFile.txt"]];
// writing values from list array to Output.txt
for [int i = 0; i < 7; i++] {
out.println["Value at: " + i + " = " + list[i]];
}
}
catch [Exception e] {
System.out.println["Exception => " + e.getMessage[]];
}
finally {
// checking if PrintWriter has been opened
if [out != null] {
System.out.println["Closing PrintWriter"];
// close PrintWriter
out.close[];
}
else {
System.out.println["PrintWriter not open"];
}
}
}
}
class Main {
public static void main[String[] args] {
ListOfNumbers list = new ListOfNumbers[];
list.writeList[];
}
}
1.Its syntax is:
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[]];
}
}
}
2To learn more, visit Java catching multiple exceptions.
Java try-with-resources statement
The try-with-resources statement is also referred to as automatic resource management. This statement automatically closes all the resources at the end of the statement.