In Java, the static
keyword is primarily used for memory management. It can be applied to variables, methods, blocks, and nested classes. During the JVM class loading process, JVM class loader subsystem first looks for static members and executes static blocks and initialise static variables as part of the class initialisation stage (learn more on Initialisation).
Static variable
Static variable also known as class variable, it is shared among all instances of the class. They are initialised only once when the class is loaded to the memory and stored in the JVM method area.
public class Example {
static int count = 0; // static variable
Example() {
count++;
System.out.println(count);
}
public static void main(String args[]) {
Example obj1 = new Example();
Example obj2 = new Example();
}
}
1
2
Static method
Static method is belong to a class rather than the instances of the class. They can be called without creating an instance of the class. Static methods can access static variables and methods directly but cannot access instance variables and methods directly.
Important
public class Example {
static int count = 0;
int value = 0;
// static method
static void incrementCount() {
count++;
}
static void printValue() {
// this will cause an error, static method can't access instance variable
System.out.println("Value is: " + value);
}
public static void main(String args[]) {
Example.incrementCount();
System.out.println(Example.count);
}
}
1
To access a non-static variable from a static method, you can either pass an instance of the class (dependency injection) or create a new instance within the static method (static dependency) Dependency injection
public class Example {
int value = 0;
static void printValue(Example obj) {
System.out.println("Value is: " + obj.value);
}
public static void main(String args[]) {
Example myExample = new Example();
Example.printValue(myExample);
}
}
Static dependency
public class Example {
int value = 0;
static void printValue() {
Example myExample = new Example();
System.out.println("Value is: " + myExample.value);
}
public static void main(String args[]) {
Example.printValue();
}
}
Static block
Code inside a static block is executed only only once when the class is first loaded by JVM. It is often used to initialise static members.
Note
The static blocks are executed before main method invocation. This is discussed in the JVM class loader subsystem.
public class Example {
static int count;
// static block
static {
count = 10;
System.out.println("Static block initialised.");
}
public static void main(String args[]) {
System.out.println(count);
}
}
Static block initialised.
10
Static nested class
A static nested class or static inner class is defined inside another class.
- Different from normal nested class, static nested class can be instantiated without the instance of the outer class.
- A static nested class can access static members of the outer class, including private members.
- A non-static nested class has full access to the members of the class within which it is nested. A static nested class does not have a reference to a nesting instance, so a static nested class cannot invoke non-static methods or access non-static fields of an instance of the class within which it is nested.
public class OuterClass {
static int outerStaticVar = 100;
int outerInstanceVar = 200;
// static nested class
static class NestedStaticClass {
void display() {
// can access static members of the outer class
// without instantiate the outer class
System.out.println("Outer static variable: " + outerStaticVar);
// cannot access non-static (instance) members of the outer class
// the following line will raise an error
// System.out.println("Outer instance variable: " + outerInstanceVar);
}
}
public static void main(String[] args) {
// instantiating the static nested class
OuterClass.NestedStaticClass nestedObject = new OuterClass.NestedStaticClass();
nestedObject.display();
}
}
Outer static variable: 100
To access the instance variable of the outer class, you have to instantiate the outer class object.
public class OuterClass {
// ...
static class NestedStaticClass {
void display() {
OuterClass outerInstance = new OuterClass();
System.out.println("Outer instance variable: " + outerInstance.outerInstanceVar);
}
}
}
Back to parent page: Java Standard Edition (Java SE) and Java Programming
Web_and_App_Development Programming_Languages Java Static Static_Method Static_Variable Static_Block Static_Nested_Class NestedClass