Points to Remember:
1) A constructor cannot be declared as final.
2) Local final variable must be initializing during declaration.
3) All variables declared in an interface are by default final.
4) We cannot change the value of a final variable.
5) A final method cannot be overridden.
6) A final class not be inherited.
7) If method parameters are declared final then the value of these parameters cannot be changed.
8) It is a good practice to name final variable in all CAPS.
9) final, finally and finalize are three different terms. finally is used in exception handling and finalize is a method that is called by JVM during garbage collection.
final variable
final variables are nothing but constants. We cannot change the
value of a final variable once it is initialized. Lets have a look at the below
code:
class Demo{
final int MAX_VALUE=99;
void myMethod(){
MAX_VALUE=101;
}
public static void main(String args[]){
Demo obj=new Demo();
obj.myMethod();
}
}
Output:
Exception in thread "main" java.lang.Error: Unresolved compilation problem:
The final field Demo.MAX_VALUE cannot be assigned
at beginnersbook.com.Demo.myMethod(Details.java:6)
at beginnersbook.com.Demo.main(Details.java:10)
We got a compilation error in the above program because we tried
to change the value of a final variable “MAX_VALUE”.
Note: It is considered as a good practice to have constant names
in UPPER CASE(CAPS).
Blank final variable
A final variable that is not initialized at the time of
declaration is known as blank final variable. We must initialize the blank final variable
in constructor of the class otherwise it will throw a
compilation error (Error: variable MAX_VALUE might not have been initialized).
This is how a blank final variable is used in a class:
class Demo{
//Blank final variable
final int MAX_VALUE;
Demo(){
//It must be initialized in
constructor
MAX_VALUE=100;
}
void myMethod(){
System.out.println(MAX_VALUE);
}
public static void main(String args[]){
Demo obj=new Demo();
obj.myMethod();
}
}
Output:
100
Uninitialized static final variable
A static final variable that is not initialized during
declaration can only be initialized in static block. Example:
class Example{
//static blank final variable
static final int ROLL_NO;
static{
ROLL_NO=1230;
}
public static void main(String args[]){
System.out.println(Example.ROLL_NO);
}
}
Output:
1230
final method
A final method cannot be overridden. Which means even though a
sub class can call the final method of parent class without any issues but it
cannot override it.
Example:
class XYZ{
final void demo(){
System.out.println("XYZ Class Method");
}
}
class ABC extends XYZ{
void demo(){
System.out.println("ABC Class Method");
}
public static void main(String args[]){
ABC obj= new ABC();
obj.demo();
}
}
The above program would throw a compilation error, however we
can use the parent class final method in sub class without any issues. Lets
have a look at this code: This program would run fine as we are not overriding the
final method. That shows that final methods are inherited but they
are not eligible for overriding.
class XYZ{
final void demo(){
System.out.println("XYZ Class Method");
}
}
class ABC extends XYZ{
public static void main(String args[]){
ABC obj= new ABC();
obj.demo();
}
}
Output:
XYZ Class Method
3) final class
We cannot extend a final class. Consider the below example:
final class XYZ{
}
class ABC extends XYZ{
void demo(){
System.out.println("My Method");
}
public static void main(String args[]){
ABC obj= new ABC();
obj.demo();
}
}
Output:
The type ABC cannot subclass the final class XYZ
No comments:
Post a Comment