13 KiB
Understanding Static and Final Keyword in Java
Static Keyword
Java uses static keyword at 4 different places. Lets learn about each of them.
- Static Instance Variables
- Static Methods
- Static Block
- Static Classes.
Static Members and Methods There will be times when you will want to define a class member that will be used independently of any object of that class. Normally, a class member must be accessed only in conjunction with an object of its class. However, it is possible to create a member that can be used by itself, without reference to a specific instance.
To create such a member, precede its declaration with the keyword static. When a member is declared static, it can be accessed before any objects of its class are created, and without reference to any object. You can declare both methods and variables to be static.
The most common example of a static member is main( ). main( ) is declared as static because it must be called before any objects exist.
Instance variables declared as static are, essentially, global variables. When objects of its class are declared, no copy of a static variable is made. Instead, all instances of the class share the same static variable.
Math.java
public class Math {
static String author = "Prateek";
static int area(int l,int b){
return l*b;
}
}
In the above example the static keywod has been used to create a static data member and a static method. We don't need create a Math Class objects to acess the methods and data members, instead we can directly refer Math.author and Math.area(v1,v2) from main.
public static void main(String[] args) {
//static block will execute when the class is loaded
System.out.println("Area of Rectangle " + Math.area(10,20));
System.out.println(Math.author);
}
Restrictions on Static Methods:
• They can only directly call other static methods of their class.
• They can only directly access static variables of their class.
• They cannot refer to this or super in any way. (Super keyword is used in inheritance)
Static Block If you need to do computation in order to initialize your static variables, you can declare a static block that gets executed exactly once, when the class is first loaded. As soon as the class is loaded, all of the static statements are run.
public class StaticDemoExample {
static int a = 3;
static int b;
static{
System.out.println("Inside Static Block");
b = a*4;
printData();
}
static void printData(){
System.out.println(a);
System.out.println(b);
}
public static void main(String[] args) {
//static block will execute when the class is loaded
// it is used to init static variables
}
}
In the above code, static block will automatically as you launch the program, the class is loaded and static block is executed. Despite the main being empty, the code will output the following as static block is still executed.
Code Output
Inside Static Block
3
12
Nested Classes and 'Static' Modifier
It is possible to define a class within another class; such classes are known as nested classes. There are two types of nested classes: static and non-static. Lets learn about them.
Static Nested Class (Static Inner Class):
- A static nested class is a nested class that is declared as static.
- It does not have access to the instance-specific members of the outer class.Because it is static, it must access the non-static members of its enclosing class through an object.
- You can create an instance of a static nested class without creating an instance of the outer class.
- Static nested classes are often used for grouping related utility methods or encapsulating code within a class.
- Note: In Java, only nested classes are allowed to be static.
public class OuterClass {
// Outer class members
static class StaticNestedClass {
// Static nested class members
}
}
Inner Class (Non-static Nested Class)
- An inner class is a nested class that is not declared as static.
- It can access both static and instance-specific members of the outer class.
- An instance of an inner class can only be created within an instance of the outer class.
- Inner classes are often used for implementing complex data structures or for achieving better encapsulation.
public class OuterClass {
// Outer class members
class InnerClass {
// Inner class members
}
}
Nested Static Classes in Builder Design Pattern This kind of class design is particularly useful in Builder Design Pattern which you will study later as a part of Low Level Design Course. In short, The Builder Design Pattern is a creational design pattern that allows you to create complex objects step by step. It's especially useful when you have an object with many optional parameters or configurations. Here's an example of how you can implement the Builder pattern in Java:
Suppose you want to create a Person class with optional attributes like name, age, address, and phone number using the Builder pattern:
public class Person {
private String name;
private int age;
private String address;
private String phoneNumber;
// Private constructor to prevent direct instantiation
private Person() {
}
// Nested Builder class
public static class Builder {
private String name;
private int age;
private String address;
private String phoneNumber;
public Builder(String name) {
this.name = name;
}
public Builder age(int age) {
this.age = age;
return this;
}
public Builder address(String address) {
this.address = address;
return this;
}
public Builder phoneNumber(String phoneNumber) {
this.phoneNumber = phoneNumber;
return this;
}
public Person build() {
Person person = new Person();
person.name = this.name;
person.age = this.age;
person.address = this.address;
person.phoneNumber = this.phoneNumber;
return person;
}
}
// Getter methods for Person class
public String getName() {
return name;
}
public int getAge() {
return age;
}
public String getAddress() {
return address;
}
public String getPhoneNumber() {
return phoneNumber;
}
@Override
public String toString() {
return "Name: " + name + ", Age: " + age + ", Address: " + address + ", Phone: " + phoneNumber;
}
}
PersonDemo.java
public class PersonDemo {
public static void main(String[] args) {
Person person1 = new Person.Builder("John")
.age(30)
.address("123 Main St")
.phoneNumber("555-1234")
.build();
Person person2 = new Person.Builder("Alice")
.age(25)
.phoneNumber("555-5678")
.build();
System.out.println(person1);
System.out.println(person2);
}
}
This allows you to create Person objects with various combinations of attributes while keeping the code clean and readable.
Final Keyword
The keyword final has three uses. First, it can be used to create the equivalent of a named constant. The other two uses of final apply to inheritance as discussed below.
1. Final in Variables A field can be declared as final. Doing so prevents its contents from being modified, making it, essentially, a constant. This means that you must initialize a final field when it is declared. You can do this in one of two ways: First, you can give it a value when it is declared. Second, you can assign it a value within a constructor. The first approach is probably the most common. Here is an example:
final int FILE_NEW = 1;
final int FILE_OPEN = 2;
final int FILE_SAVE = 3;
final int FILE_SAVEAS = 4;
final int FILE_QUIT = 5;
Subsequent parts of your program can now use FILE_OPEN, etc., as if they were constants, without fear that a value has been changed. It is a common coding convention to choose all uppercase identifiers for final fields, as this example shows.
In addition to fields, both method parameters and local variables can be declared final. Declaring a parameter final prevents it from being changed within the method. Declaring a local variable final prevents it from being assigned a value more than once.
The keyword final can also be applied to methods, but its meaning is substantially different than when it is applied to variables.
2. Using final to Prevent Method Overriding While method overriding is one of Java’s most powerful features, there will be times when you will want to prevent it from occurring. To disallow a method from being overridden, specify final as a modifier at the start of its declaration. Methods declared as final cannot be overridden. The following fragment illustrates final.
Because meth( ) is declared as final, it cannot be overridden in B. If you attempt to do so, a compile-time error will result.
Methods declared as final can sometimes provide a performance enhancement: The compiler is free to inline calls to them because it “knows” they will not be overridden by a subclass. When a small final method is called, often the Java compiler can copy the bytecode for the subroutine directly inline with the compiled code of the calling method, thus eliminating the costly overhead associated with a method call. Inlining is an option only with final methods. Normally, Java resolves calls to methods dynamically, at run time. This is called late binding. However, since final methods cannot be overridden, a call to one can be resolved at compile time. This is called early binding.
3. Using final to Prevent Inheritance Sometimes you will want to prevent a class from being inherited. To do this, precede the class declaration with final. Declaring a class as final implicitly declares all of its methods as final, too. As you might expect, it is illegal to declare a class as both abstract and final since an abstract class is incomplete by itself and relies upon its subclasses to provide complete implementations.
Here is an example of a final class:
As the comments imply, it is illegal for B to inherit A since A is declared as final.