What is a static keyword in Java?
In Java, if we want to access class members, we must first create an instance of the class. But there will be situations where we want to access class members without creating any variables.
In those situations, we can use the static
keyword in Java. If we want to access class members without creating an instance of the class, we need to declare the class members static.
The Math
class in Java has almost all of its members static. So, we can access its members without creating instances of the Math class. For example,
public class Main {
public static void main( String[] args ) {
// accessing the methods of the Math class
System.out.println("Absolute value of -12 = " + Math.abs(-12));
System.out.println("Value of PI = " + Math.PI);
System.out.println("Value of E = " + Math.E);
System.out.println("2^2 = " + Math.pow(2,2));
}
}
Output:
Absolute value of -12 = 12 Value of PI = 3.141592653589793 Value of E = 2.718281828459045 2^2 = 4.0
In the above example, we have not created any instances of the Math
class. But we are able to access its methods: abs()
and pow()
and variables: PI
and E
.
It is possible because the methods and variables of the Math
class are static.
Static Methods
Static methods are also called class methods. It is because a static method belongs to the class rather than the object of a class.
And we can invoke static methods directly using the class name. For example,
class Test {
// static method inside the Test class
public static void method() {...}
}
class Main {
// invoking the static method
Test.method();
}
Here, we can see that the static method can be accessed directly from other classes using the class name.
In every Java program, we have declared the main
method static
. It is because to run the program the JVM should be able to invoke the main method during the initial phase where no objects exist in the memory.
Example 1: Java static and non-static Methods
class StaticTest {
// non-static method
int multiply(int a, int b){
return a * b;
}
// static method
static int add(int a, int b){
return a + b;
}
}
public class Main {
public static void main( String[] args ) {
// create an instance of the StaticTest class
StaticTest st = new StaticTest();
// call the nonstatic method
System.out.println(" 2 * 2 = " + st.multiply(2,2));
// call the static method
System.out.println(" 2 + 3 = " + StaticTest.add(2,3));
}
}
Output:
2 * 2 = 4 2 + 3 = 5
In the above program, we have declared a non-static method named multiply()
and a static method named add()
inside the class StaticTest
.
Inside the Main class, we can see that we are calling the non-static method using the object of the class (st.multiply(2, 2)
). However, we are calling the static method by using the class name (StaticTest.add(2, 3)
).
Static Variables
In Java, when we create objects of a class, then every object will have its own copy of all the variables of the class. For example,
class Test {
// regular variable
int age;
}
class Main {
// create instances of Test
Test test1 = new Test();
Test test2 = new Test();
}
Here, both the objects test1 and test2 will have separate copies of the variable age. And, they are different from each other.
However, if we declare a variable static, all objects of the class share the same static variable. It is because like static methods, static variables are also associated with the class. And, we don't need to create objects of the class to access the static variables. For example,
class Test {
// static variable
static int age;
}
class Main {
// access the static variable
Test.age = 20;
}
Here, we can see that we are accessing the static variable from the other class using the class name.
Example 2: Java static and non-static Variables
class Test {
// static variable
static int max = 10;
// non-static variable
int min = 5;
}
public class Main {
public static void main(String[] args) {
Test obj = new Test();
// access the non-static variable
System.out.println("min + 1 = " + (obj.min + 1));
// access the static variable
System.out.println("max + 1 = " + (Test.max + 1));
}
}
Output:
min + 1 = 6 max + 1 = 11
In the above program, we have declared a non-static variable named min and a static variable named max inside the class Test.
Inside the Main class, we can see that we are calling the non-static variable using the object of the class (obj.min + 1
). However, we are calling the static variable by using the class name (Test.max + 1
).
Note: Static variables are rarely used in Java. Instead, the static constants are used. These static constants are defined by static final
keyword and represented in uppercase. This is why some people prefer to use uppercase for static variables as well.
Access static Variables and Methods within the Class
We are accessing the static variable from another class. Hence, we have used the class name to access it. However, if we want to access the static member from inside the class, it can be accessed directly. For example,
public class Main {
// static variable
static int age;
// static method
static void display() {
System.out.println("Static Method");
}
public static void main(String[] args) {
// access the static variable
age = 30;
System.out.println("Age is " + age);
// access the static method
display();
}
}
Output:
Age is 30 Static Method
Here, we are able to access the static variable and method directly without using the class name. It is because static variables and methods are by default public. And, since we are accessing from the same class, we don't have to specify the class name.
Static Blocks
In Java, static blocks are used to initialize the static variables. For example,
class Test {
// static variable
static int age;
// static block
static {
age = 23;
}
}
Here we can see that we have used a static block with the syntax:
static {
// variable initialization
}
The static block is executed only once when the class is loaded in memory. The class is loaded if either the object of the class is requested in code or the static members are requested in code.
A class can have multiple static blocks and each static block is executed in the same sequence in which they have been written in a program.
Example 3: Use of static block in java
class Main {
// static variables
static int a = 23;
static int b;
static int max;
// static blocks
static {
System.out.println("First Static block.");
b = a * 4;
}
static {
System.out.println("Second Static block.");
max = 30;
}
// static method
static void display() {
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("max = " + max);
}
public static void main(String args[]) {
// calling the static method
display();
}
}
Output:
First Static block. Second Static block. a = 23 b = 92 max = 30
In the above program. as soon as the Main class is loaded,
- The value of a is set to
23
. - The first static block is executed. Hence, the string
First Static block
is printed and the value of b is set toa * 4
. - The second static block is executed. Hence, the string
Second Static block
is printed and the value of max is set to30
. - And finally, the print statements inside the method
display()
are executed.
Nested Static Class
In Java, we can declare a class inside another class. Such classes are known as nested classes. Nested classes are of 2 types:
- Static Nested Classes
- Non-static Nested Classes
For example,
class OuterClass {
// static nested class
static class NestedClass {...}
// non-static nested class
class InnerClass {...}
}
To learn more, visit the Java Nested Class.