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

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.

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.

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

Java Exception Handling Keywords

Java consists of five keywords to handle various kinds of custom exceptions. They are:

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

1. 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());
      }
     }
    }

   Run Code >>

   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

2. 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");
     }
   }
   

   Run Code >>

   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
   

3. 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");
       }
     }
   }
   

   Run Code >>

   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

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

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.

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