Static Keyword in Java

Last Updated: 21 October, 2024

In Java, static keyword is a non-access modifier that is used to define variables, methods, blocks, and nested classes. All the static properties belong to the class. So it's also called a class member.

To access static properties outside the class, we don't need objects of the class. We can access all the static properties with the class name using the . (dot) operator.

For example,

class_name . static_property_name;

The Static keyword can be used with:

Variable

Method

Block

Nested class

1. Static Variables in Java

If we declare a variable with the static keyword, that variable is known as a static variable in Java. The static variable belongs to the class and is accessible outside the class using the class name (object creation is not required to access static variables), so it's also called a class variable.

Static variables share the same memory for all the instances of a class. These variables are stored in a space called metaspace in the JVM memory pool.

Static variables are initialized when a class is loaded into memory and are discarded when the classloader for that class is unloaded. They can be cleaned up, even duplicated in another class loader.

Example 1 : Static Variables in Java

// Java Program to demonstrate the use of static variable class Employee { int empId; String empName; static String orgName = "Xyz Pvt. Ltd."; // static variable // constructor Employee(int empId, String empName) { this.empId = empId; this.empName = empName; } void printEmpRecord() { // An Instance method can have static properties System.out.println("Emp ID: " + empId + ", Emp Name: " + empName + ", Org Name: " + orgName); } } public class StaticVariableExample { public static void main(String[] args) { Employee emp1 = new Employee(101, "John"); Employee emp2 = new Employee(102, "Shyam"); emp1.printEmpRecord(); emp2.printEmpRecord(); // 1. Accessing static variable outside with using the class name // 2. Changing the static variable value will be common effect for all the objects Employee.orgName = "Abc Technologies Pvt. Ltd."; System.out.println("\nAfter updating static variable:"); emp1.printEmpRecord(); emp2.printEmpRecord(); } }

Output

Emp ID: 101, Emp Name: John, Org Name: Xyz Pvt. Ltd.
Emp ID: 102, Emp Name: Shyam, Org Name: Xyz Pvt. Ltd.

After updating static variable:
Emp ID: 101, Emp Name: John, Org Name: Abc Technologies Pvt. Ltd.
Emp ID: 102, Emp Name: Shyam, Org Name: Abc Technologies Pvt. Ltd.

2. Static Method In Java

If we declare a method with the static keyword, that method is known as a static method in Java. A static method belongs to a class rather than an instance of a class, so it's also known as a class method.

In Java, if we have to perform some common functionality where object dependencies have not required those methods, we declare it a static method.

All static methods are accessible outside the class using the class name. For example, class-name.method-name();

Some important points about the static method:

A static method can contain only static properties, such as static variables and static methods.

A static method does not contain instance properties like instance variables and instance methods.

We cannot use this and super keywords inside the static method.

Example 2 : Static Methods in Java

// Java Program to demonstrate the use of static methods class Test { static int number1 = 100; int number2 = 200; // static method static void display() { System.out.println("static display() methed called."); // A static method can access only static property of a class System.out.println(number1); // A static method cannot access instance property of a class // System.out.println(number2); } // another static method of a class static void show() { System.out.println("static show() methed called."); } } public class StaticMethodExample { public static void main(String[] args) { // Accessing static method using class name, no object creation required. Test.display(); Test.show(); } }

Output

static display() methed called.
100
static show() methed called.

3. Static Block in Java

A block that is declared with the static keyword is known as a static block in Java. It is used for initializing static variables. The static block gets executed at the time the class is loaded into memory.

Java allows writing multiple static blocks in a single class. The multiple static blocks will be executed one by one in the same order in which they were written in the Java class.

An interface does not allow writing static blocks inside it.

Example 3 : Static Blocks in Java

// Java Program to demonstrate the use of static blocks package com.javabytechie.staticblocks; class Test { static { System.out.println("Static Block 1 is executed."); } static { System.out.println("Static Block 2 is executed."); } static { System.out.println("Static Block 3 is executed."); } } public class StaticBlockExample { public static void main(String[] args) throws ClassNotFoundException { // Loading the class in the memory Class.forName("com.javabytechie.staticblocks.Test"); } }

Output

Static Block 1 is executed.
Static Block 2 is executed.
Static Block 3 is executed.

4. Static Nested class in Java

A class that is defined inside another class with the static keyword is known as a static nested class in Java. A static nested class cannot access the outer class's non-static properties but can access static properties. A static nested class is always accessed from outside with the outer class name.

Syntax: Static Nested Class in Java

class OuterClass { // code static class NestedStaticClass { // code } }

Example 4 : Static Nested Class in Java

// Java Program to demonstrate the use of static nested class class OuterClass { // Static Variable static int num = 20; // Static Method static void display() { System.out.println("OuterClass - static display() method"); } static class NestedStaticClass { // Static Method static void staticMethod() { // Accessing OuterClass static properties display(); System.out.println("num : " + num); } } } public class StaticNestedClassExample2 { public static void main(String[] args) { // Calling NestedStaticClass static method OuterClass.NestedStaticClass.staticMethod(); } }

Here, we have a class named OuterClass that has only static properties such as a static variable, a static method, and a static class known as a static inner class in Java. As we can see, the static inner class has a static method, and that method accesses the static variable and static method of the outer class directly. A static inner class can be accessed from outside using the class name.

Output

OuterClass - static display() method
num : 20

Read more...

Role of Static in Java Memory Management

In Java, static is mainly used for memory management because static properties are common to all instances of a class. Static properties occupy memory only once at class load time, whereas instance properties occupy memory each time we create the object.

From a memory perspective, static variables are stored in heap memory.

In the above diagram, there are two static properties: schoolName and schoolRegINo, which are common for each object. It will occupy memory only once. whereas the JVM allocates memory multiple times for each instance property (stuName, stuID) according to the number of objects created.