Static Keyword in Java

Introduction

The static keyword in Java is a non-access modifier used to create members that belong to a class instead of individual objects.

A static member is shared by all objects of the class and can be accessed using the class name. An object is not required to access it.

The static keyword is commonly used with:

Variables
Methods
Blocks

Static Keyword

Static Variable in Java

A static variable, also called a class variable, belongs to the class and is shared among all its objects.

Only one copy of a static variable is created. If one object changes its value, the updated value is visible to the other objects.

Static Variable Example

1// Class used to count created objects
2class Counter {
3
4    // Static variable is shared by all Counter objects
5    static int count = 0;
6
7    // Constructor runs whenever an object is created
8    Counter() {
9
10        // Increase the shared static variable
11        count++;
12    }
13}
14
15public class Main {
16    public static void main(String[] args) {
17
18        // Create the first Counter object
19        Counter first = new Counter();
20
21        // Create the second Counter object
22        Counter second = new Counter();
23
24        // Access the static variable using the class name
25        System.out.println("Total objects: " + Counter.count); // Output :- Total objects: 2
26    }
27}

In this example, count is shared by both objects. Each time an object is created, the same variable is increased.

Static Variable

Static Method in Java

A static method belongs to the class instead of an object. It can be called directly using the class name.

Static methods are commonly used for operations that do not depend on an object’s individual data.

Static Method Example

1// Utility class containing a static method
2class MathUtils {
3
4    // Static method calculates the square of a number
5    static int square(int number) {
6
7        // Return the calculated result
8        return number * number;
9    }
10}
11
12public class Main {
13    public static void main(String[] args) {
14
15        // Call the static method using the class name
16        int result = MathUtils.square(5);
17
18        // Display the returned value
19        System.out.println(result); // Output :- 25
20    }
21}

The square() method is called using MathUtils.square(5). No MathUtils object is required.

Static Method

Static Block in Java

A static block is a block of code used to initialize static variables. It runs once when the class is initialized.

A static block runs before objects of the class are created and before the class’s static members are used.

Static Block Example

1// Class containing a static variable and static block
2class Configuration {
3
4    // Declare a static variable
5    static String applicationName;
6
7    // Static block runs once when the class is initialized
8    static {
9
10        // Initialize the static variable
11        applicationName = "Learning App";
12
13        // Confirm that the static block has executed
14        System.out.println("Static block executed."); // Output :- Static block executed.
15    }
16}
17
18public class Main {
19    public static void main(String[] args) {
20
21        // Accessing the class causes its static initialization
22        System.out.println(Configuration.applicationName); // Output :- Learning App
23    }
24}

Static blocks are useful when initializing static variables requires calculations or multiple statements.

Static Block

Static vs Non-Static Members

Static Members	Non-Static Members
Belong to the class	Belong to individual objects
Shared by all objects	Each object has its own copy
Accessed using the class name	Accessed using an object
Do not require object creation	Require an object for access
Cannot directly access instance members	Can access static and instance members

Advantages of the Static Keyword

Shares common data among objects
Allows methods to run without object creation
Provides one-time class initialization
Helps create utility methods
Can be used to define shared counters and constants

Summary

The static keyword in Java creates members that belong to a class rather than its objects.

A static variable stores shared data, a static method can run without an object, and a static block performs one-time initialization of static members.