About Final Keyword

Important points on final in Java:

1. Final keyword can be applied to member variable, local variable, method or class in Java.

2. Final member variable must be initialized at the time of declaration or inside constructor, failure to do so will result in compilation error.

3. You can not reassign value to final variable in Java.

4. Local final variable must be initializing during declaration.

5. Only final variable is accessible inside anonymous class in Java.

6. Final method can not be overridden in Java.

7. Final class can not be inheritable in Java.

8. Final is different than finally keyword which is used on Exception handling in Java.

9. Final should not be confused with finalize() method which is declared in object class and called before an object is garbage collected by JVM.

10. All variable declared inside java interface are implicitly final.

11. Final and abstract are two opposite keyword and a final class can not be abstract in java.

12. Final methods are bonded during compile time also called static binding.

13. Final variables which is not initialized during declaration are called blank final variable and must be initialized on all constructor either explicitly or by calling this(). Failure to do so compiler will complain as "final variable (name) might not be initialized".

14. Making a class, method or variable final in Java helps to improve performance because JVM gets an opportunity to make assumption and optimization.

15. As per Java code convention final variables are treated as constant and written in all Caps e.g.

private final int COUNT=10;

16. Making a collection reference variable final means only reference can not be changed but you can add, remove or change object inside collection. For example:

private final List Loans = new ArrayList();

list.add(“home loan”);  //valid

list.add("personal loan"); //valid

loans = new Vector();  //not valid

That’s all on final in Java. We have seen what final variable, final method is and final class in Java and what does those mean. In Summary whenever possible start using final in java it would result in better and faster code.

Important Point In Java 8:

One more thing to note about final variables in Java is that, till Java 7, you can not use a non final local variable inside anonymous class, but from Java 8 you can. JDK 8 introduced a concept called effective final, a variable is considered effective final if it is not modified after initialization in local block. What this means is you can now use local variable without final keyword inside anonymous class or lambda expression, provided they must be effectively final. In short, you can save some keystroke while declaring local final variables indented to be used by anonymous class. Here is an example of using effective final variable in Java 8 :


public class EffectiveFinalJava8 {

public static void main(String[] args) {

String nonFinal = "I am non final local variable";
Runnable r = new Runnable() {
@Override
public void run() {
System.out.println("Using non-final local variable inside anonymous class in Java");
System.out.println("Value of non-final variable is : " + nonFinal);

// compile time error - must be final or effective final
// nonFinal = "Can I change non-final variable inside anonymous class";
}
};
}

}

Benefits of final keyword in Java:

Here are few benefits or advantage of using final keyword in Java:

1. Final keyword improves performance. Not just JVM can cache final variable but also application can cache frequently use final variables.

2. Final variables are safe to share in multi-threading environment without additional synchronization overhead.

3. Final keyword allows JVM to optimized method, variable or class.

Example of Final variable, Final method and Class in Java

What is final keyword in Java?

Final is a keyword or reserved word in java and can be applied to member variables, methods, class and local variables in Java. Once you make a reference final you are not allowed to change that reference and compiler will verify this and raise compilation error if you try to re-initialized final variables in java.

What is final variable in Java?

Any variable either member variable or local variable (declared inside method or block) modified by final keyword is called final variable. Final variables are often declare with static keyword in java and treated as constant. Here is an example of final variable in Java

public static final String LOAN = "loan";

LOAN = new String("loan") //invalid compilation error

Final variables are by default read-only.

What is final method in Java

Final keyword in java can also be applied to methods. A java method with final keyword is called final method and it can not be overridden in sub-class. You should make a method final in java if you think it’s complete and its behavior should remain constant in sub-classes. Final methods are faster than non-final methods because they are not required to be resolved during run-time and they are bonded on compile time. Here is an example of final method in Java:

class PersonalLoan{

 public final String getName(){

     return "personal loan";

 }

}

class CheapPersonalLoan extends PersonalLoan{

    @Override

    public final String getName(){

        return "cheap personal loan"; //compilation error: overridden method is final

    }

}

What is final Class in Java

Java class with final modifier is called final class in Java. Final class is complete in nature and can not be sub-classed or inherited. Several classes in Java are final e.g. String, Integer and other wrapper classes. Here is an example of final class in java

final class PersonalLoan{

}

class CheapPersonalLoan extends PersonalLoan{  //compilation error: cannot inherit from final class

}

Difference between Final,Finally and Finalize :

final: final is a keyword. The variable declared as final should be initialized only once and cannot be changed. Java classes declared as final cannot be extended. Methods declared as final cannot be overridden. 

finally: finally is a block. The finally block always executes when the try block exits. This ensures that the finally block is executed even if an unexpected exception occurs. But finally is useful for more than just exception handling - it allows the programmer to avoid having clean up code accidentally bypassed by a return, continue, or break. Putting clean up code in a finally block is always a good practice, even when no exceptions are anticipated.

 finalize: finalize is a method. Before an object is garbage collected, the runtime system calls its finalize() method. You can write system resources release code in finalize() method before getting garbage collected.