Java static Keyword

In Java, static is a non-access modifier that can be applied to variables, methods, blocks, and even nested classes. When a member is declared as static, it becomes associated with the class itself rather than individual objects (instances) of that class.

Key characteristics of static members

  1. Shared across all instances: There's only one copy of a static member in memory, regardless of how many objects you create from the class. Any changes made to a static member by one object reflect in all other objects.
  2. Accessible without object creation: You can access static members directly using the class name, eliminating the need to first create an object. This is particularly useful for constants and utility methods.
  3. Limited functionality in methods: Static methods cannot access non-static members (variables or methods) of the class directly. They can only operate on other static members or use arguments passed to them.

Applications of static

Here's a breakdown of how static is used with examples:

Static Variables (Class Variables)

Static variables are shared among all instances of a class. They are initialized only once, at the start of the execution, and remain in memory until the program ends. These variables are accessed using the class name, not through an instance of the class.

class MyClass { static int count = 0; // static variable MyClass() { count++; // accessing and modifying static variable } } public class Main { public static void main(String[] args) { MyClass obj1 = new MyClass(); MyClass obj2 = new MyClass(); System.out.println(MyClass.count); // Output: 2 } }

n this example, the count variable is shared among all instances of the MyClass. Every time a new object of MyClass is created, the count increments.

Static Methods

Static methods belong to the class rather than any particular instance. They can be called using the class name without the need to create an instance of the class.

class MathUtils { static int add(int a, int b) { return a + b; } } public class Main { public static void main(String[] args) { int result = MathUtils.add(5, 3); System.out.println(result); // Output: 8 } }

Here, add() is a static method of the MathUtils class. It can be called directly using MathUtils.add() without creating an instance of MathUtils.

Static Blocks

Static blocks are used to initialize static variables. They are executed only once when the class is loaded into memory.

class StaticExample { static int num; static { num = 10; System.out.println("Static block initialized. Value of num: " + num); } } public class Main { public static void main(String[] args) { // No need to create an object of StaticExample System.out.println("Value of num: " + StaticExample.num); // Output: 10 } }

In this example, the static block is executed when the class StaticExample is loaded into memory, initializing the static variable num to 10.

Static Nested Classes

Inner classes can also be declared static. These classes belong to the outer class, not to any instance of the outer class.

class OuterClass { static class StaticNestedClass { void display() { System.out.println("This is a static nested class."); } } } public class Main { public static void main(String[] args) { OuterClass.StaticNestedClass nestedObj = new OuterClass.StaticNestedClass(); nestedObj.display(); // Output: This is a static nested class. } }

Here, StaticNestedClass is a static nested class within OuterClass. It can be accessed using the outer class name.

Points to Remember:
  1. Use static judiciously. Overuse can lead to tight coupling between classes and make code less flexible.
  2. When possible, favor non-static members for better encapsulation and object-oriented principles.


The static keyword in Java is used to define elements that are shared among all instances of a class, including variables, methods, blocks, and nested classes. It promotes code reusability and memory efficiency by allowing elements to be accessed without the need for object instantiation.