Skip to main content

finally block

Java Exception Handling: Finally, Final, and Finalize

Finally

Finally: Finally is a block always associated with try-catch to maintain clean-up code. The speciality of the finally block is that it will be executed irrespective of whether an exception is raised or not raised and whether it is handled or not handled.

Syntax:

try {
    risky code
} catch(Exception e) {
    throw exception
} finally {
    clean-up activity
}

Final

Final: Final is a modifier applicable for classes, methods, and variables.

  1. If a class is declared as final, we can't extend that class (i.e., we can't create child classes for that class; inheritance is not possible for final classes).
  2. If a method is final, we can't override that method in the child class.
  3. If a variable is declared as final, then we can't perform reassignment for that variable.

Finalize()

Finalize(): Finalize is a method always invoked by the garbage collector just before destroying an object to perform clean-up activities. Once the finalize method completes, the garbage collector immediately destroys the object.

Note:

  • The finally block is responsible for performing clean-up activities related to the try block (i.e., whatever resources we open as part of the try block will be closed inside the finally block).
  • The finalize method is responsible for performing clean-up activities related to the object (i.e., whatever resources are associated with the object will be deallocated before destroying the object by using the finalize method).

Various Possible Combinations of try-catch-finally

Valid Combination 1 Valid Combination 2 Invalid Combination 1 
try {
    // code
} catch(Exception e) {
    // code
}
 
try {
    // code
} catch(ChildException e) {
    // code
} catch(ParentException e) {
    // code
}
 
try {
    // code
} catch(ParentException e) {
    // code
} catch(ParentException e) {
    // code
}

Compile time error: duplicate catch blocks
Valid Combination 3 Valid Combination 4 Invalid Combination 2 
try {
    // code
} finally {
    // code
}
 
try {
    // code
} catch(Exception e) {
    // code
} finally {
    // code
}
 
try {
    // code
}

Compile time error: try without catch or finally
Valid Combination 5 Invalid Combination 3 Invalid Combination 4 
try {
    // code
} catch(Exception e) {
    // code
}
try {
    // code
} catch(Exception e) {
    // code
}
 
catch(Exception e) {
    // code
}

Compile time error: catch without try

 
finally {
    // code
}

Compile time error: finally without try
Invalid Combination 5 Invalid Combination 6 Invalid Combination 7 
try {
    // code
} finally {
    // code
}
catch(Exception e) {
    // code
}

Compile time error: catch without try

 
try {
    // code
} catch(Exception e) {
    // code
}
System.out.println("Hello");
catch(Exception e) {
    // code
}

Compile time error: catch without try

 
try {
    // code
} catch(Exception e) {
    // code
}
System.out.println("Hello");
finally {
    // code
}

Compile time error: finally without try
Valid Combination 6 Valid Combination 7 Valid Combination 8 
try {
    try {
        // code
    } catch(Exception e) {
        // code
    }
} catch(Exception e) {
    // code
}
 
try {
    // code
} catch(Exception e) {
    try {
        // code
    } finally {
        // code
    }
}
 
try {
    // code
} catch(Exception e) {
    // code
} finally {
    try {
        // code
    } catch(Exception e) {
        // code
    }
}
Valid Combination 9 Valid Combination 10 Invalid Combination 8 
try {
    // code
} catch(Exception e) {
    // code
} finally {
    finally {
        // code
    }
}

Compile time error: finally without try

 
try {
    // code
} catch(Exception e) {
    // code
} finally {
    // code
} finally {
    // code
}

Compile time error: finally without try

 
try
    System.out.println("Hello");
catch(Exception e) {
    // code
} finally {
    // code
}

Not Allowed: Curly braces are mandatory
Invalid Combination 9 Invalid Combination 10 Invalid Combination 11 
try {
    // code
} catch(Exception e)
    e.printStackTrace();
finally {
    // code
}

Not Allowed: Curly braces are mandatory

 
try {
    // code
} catch(Exception e) {
    // code
}
finally
    System.out.println("finally");

Not Allowed: Curly braces are mandatory

Points:

  1. The order of try-catch-finally is important.
  2. Whenever writing try, we must write either catch or finally. Otherwise, we will get a compile-time error. That is, try without catch or finally is invalid.
  3. Whenever we are writing a catch block, a try block must be present; that is, catch without try is invalid.
  4. Whenever we are writing a finally block, a try block must be present; that is, finally without try is invalid.
  5. Inside try, catch, and finally blocks, we can declare try-catch-finally blocks. That is, nesting of try-catch-finally is allowed.
  6. For try, catch, and finally blocks, curly braces are mandatory.

Popular posts from this blog

Java

Codes With Java — Basics Codes With Java Java tutorials & fundamentals About Contact Privacy Basic Fundamentals Java source file structure Import Statement Static Import Packages Data Type Variables Final Variable Declaration and Access Modifier Inner classes applicable modifiers Static Modifier Synchronized Native Transient Volatile Interface Introduction Interface Declaration and Implementation Interface methods and variables Naming Conflicts Interface Marker interface and Ad...
Read more

Short Circuite Operators part 4

                                                             Short Circuit Operators In  Java logical operators , if the evaluation of a logical expression exits in between before complete evaluation, then it is known as  Short-circuit . A short circuit happens because the result is clear even before the complete evaluation of the expression, and the result is returned. Short circuit evaluation avoids unnecessary work and leads to efficient processing. 1-: AND(&&) 2-:OR(||) these are exactly same as bitwise operators (&,|) except the following differences. Single Short Circuit Operator(&,|) Both arguments Should be evaluated always. relatively performance is low. Applicable for both boolean and Integral types. Double Short Circuit Operator(...
Read more

Final Variable

Final Instance Variable If the value of a variable changes from object to object, such a variable is called an instance variable . For every object, a separate copy of the instance variable will be created. Instance variables do not require explicit initialization; JVM always provides default values. Example: class Test { int x; // instance variable public static void main(String... args) { Test t = new Test(); System.out.println(t.x); // output: 0 } } If the instance variable is declared as final , then explicit initialization is mandatory. JVM will NOT provide default values. Example: class Test { final int x; } Compile-time Error: variable x might not have been initialized. Rule: A final instance variable must be initialized before constructor completion . Possible places for initialization: 1. At the time of declaration class Test { final int x = 10; } 2. Inside an instance blo...
Read more