Java Finally Keyword

The final block in Java is used to run essential code, such as connection closure, among other things. Whether an exception is resolved or not, the Java finally block has always been run. Even the Prior execution or printing statements of the program is given we cannot know whether an exception happens or not to implement necessary statements are not.

The try-catch block is executed after the finally block is implemented or executed.

Finally Block Flow Chart

In the same manner that Java's final is a reserved keyword, finally is also a reserved keyword that cannot be used as an identifier. Finally, keyword ensures that a part of code will be run even if an exception is thrown when used in combination with a try/catch block. The control of the program to its source before the try and catch blocks are executed then last block will be executed.

Note: The JVM will implement or execute the finally block before terminating or stopping the application (if any), if we doesn’t handle the exception.

Usage of the Finally Block in Java

In Java programming language, "cleanup" code, such as terminating a file or a connection, can be inserted in the finally block. As part of programming specifications, we interface with databases by creating connections, using input and output streams, and resources inside a try block. It is advisable to use the finally block together with try-catch blocks as a good programmer to ensure the safety of resources and to make sure that there is no resource leak as part of our software.

The finally block is where you can print the essential statements.

Usage of Java keyword Finally

Let's understand and examine the various scenarios in which the Java finally block can be applied and implemented.

Case 1: In the absence of an exception

Let's look at the example below, where the Java programme doesn't raise any exceptions and the finally, block is executed following the try block.

TestFinallyBlock.java


class Fnl_Block {    
  public static void main (String s []) {
try {
// any exception is not thrown in the above code
   int ja=25/5;
   System.out.println(ja);
  }    
//executed without regard to exception happened or not
catch (NullPointerException e) {
System.out.println(e);
}    
 finally {  
System.out.println("Ececution of the finally block is always done.");
}    


System.out.println("remaining of the code...");
  }    
}    

Output:

Java finally block

Case 2: A catch block is not used when an exception occurs.

In this case, the catch block is unable to handle the exception when the code throws exception statements. Excepting this, the programme terminates improperly or irregularly after the finally block is executed after the running of try block.

public class Fnl_block_1{    
      public static void main (String s []) {
      try {    
        System.out.println("inner of try block");


        //The code below raises the divide-by-zero exception.
       int ja=25/0;
       System.out.println(ja);
      }    
//cannot handle exception of the arithmetic type
//can only accept exceptions of the Null Pointer type.
catch (Null_Pointer_Exptne) {
        System.out.println(e);
      }   
//checking whether an exception has occurred is executed or not.
      finally {  
        System.out.println("Execution of the finally block is always done");
      }    


      System.out.println("remaining of the code...");
      }    
    }    

Output:

Java finally block

Case 3: When a catch block is used to handle an exception that arises.

Example:

Let's look at the example below, where the catch block handles an exception that the Java code throws. After the block of try-catch, the finally block is then run. Additionally, the remaining code runs normally as well.

public class Fnl_Block_2{    
      public static void main (String s []){
      try {    
        System.out.println("Inner side of try block");


        //below code throws divide by zero exception  
       int ja=25/0;
       System.out.println(ja);
}  //handles the Arithmetic Exception 
            // Divide by zero


catch (Arithmetic_Exception e) {
        System.out.println("Exception handled");
        System.out.println(e);
      }   


      //regardless of whether an exception has occurred, /executes
      finally {  
        System.out.println("Execution of the final block is always done");
      }    


      System.out.println("remaining of the codeexecuted...");
      }    
    }  

Output:

Java finally block

Rule: There may be zero or more catch blocks for each attempt block, but there may only be one finally block.

Note: If the application terminates (either by calling System.exit() or by introducing a fatal error that causes the procedure to return), there they won't be carried out bt finally keyword.