How to use static keyword in Java

The static keyword in Java is a non-access modifier (keywords used to provide additional functionality such as synchronization etc), used primarily for memory management. The keyword static is used to refer to the common property of all objects.

The static keyword can be applied to variables, methods, blocks, and nested classes:

1. Static variable

If a variable is `static`, the variable is assigned memory once and all objects of the class access the same variable.

A static variable can be created by adding the static keyword before the variable during declaration.

Syntax

The general syntax for declaring a `static` variable is: 
static datatype variable-name

Example

Consider making a simple class which implements the functionality of a counter by incrementing a variable **count** by one each time an instance of the class is created.

Using a static variable will create one copy of the count variable which will be incremented every time an object of the class is created.

class Counter {
    static int count = 0;
    Counter(){
        count ++;
    }
    public void getCount() {
        System.out.printf("Value of counter: %d \n", count);
    }
    public static void main( String args[] ) {
        Counter c1 = new Counter(); //count incremented to 1
        c1.getCount();
        Counter c2 = new Counter(); //count incremented to 2
        c2.getCount();
        Counter c3 = new Counter(); //count incremented to 3
        c3.getCount();
    }
}

All objects of the Counter class will have the same value of count at any given point in time.

svg viewer

Note:

  • static variables can be created at class level only
  • A static variable is allotted memory once

2. Static method

Similar to static variables, static methods belong to the class and not every instance of the class object.

Syntax

The general syntax to create a `static` method within a class is: 
public class foo { 
   public static void foo2(){
         //code
   }
}

Example

Consider making a **Citizen** class which contains a `static` variable **country**. We can update all instances of the `static` variable using a `static` method `setCountry()`. Execute the following code to see how this works.
class Citizen {
    static String country;
    Citizen() {
        country = "Pakistan";
    }
    public static void setCountry(String c) {
        country = c;
    }
    public void getCountry() {
        System.out.printf("Current country: %s \n", country);
    }
    public static void main( String args[] ) {
        Citizen c1 = new Citizen();
        Citizen c2 = new Citizen();
        Citizen c3 = new Citizen();
        c1.getCountry();
        c2.getCountry();
        c3.getCountry();
        Citizen.setCountry("USA");
        c1.getCountry();
        c2.getCountry();
        c3.getCountry();
    }
}

Note:

  • static methods cannot use this or super keywords
  • Abstract methods cannot be static
  • static methods cannot be overridden
  • static methods can only access static variables and other static methods

3. Static blocks

A `static` block is used for initializing `static` variables. The `static` block is executed once when the first object of the class is created.

Syntax

The general syntax of creating a `static` block is:
static {
   //code
}

Example

The following code will initialize the `static` variables. Execute the code to see the values.
class Foo {
    static int a;
    static int b;
    static {
      a = 10;
      b = 2 * a;
    }
    
    public static void main( String args[] ) {
        Foo foo = new Foo();
        System.out.printf("a = %d\t b = %d ", foo.a, foo.b);
    }
}

Note:

  • There can be multiple static blocks in a class

4. Static nested class

A `static` nested class is a `static` class within a class. Static nested classes cannot access non-static data members and methods.

The static nested class can be accessed by the outer class without creating an object of the outer class.

Syntax

The general syntax to create a static nested class is: 
class OuterClass {
   static class InnerClass {
       //code
   }
}

Example

In the following example, the `static` nested class can be directly accessed in the `main()` without creating an object of the outer class. 
class OuterClass {
    static String message = "Hello World!";
    static class InnerClass {
      static void getMessage(){
        System.out.println( message );
      }
    }
    public static void main( String args[] ) {
      OuterClass.InnerClass.getMessage();
    }
}

Note:

  • A static nested class cannot access instance variables and methods of the outer class without the object’s reference
  • A static nested class can access all static variables and methods of the outer class
  • In Java, the outer class cannot be static

In Java, the main method is always static because it is executed before creating an instance of the class which contains the main method.

Free AI Mock Interviews
Coding Interview
Coding PatternsFree Interview
Gain insights and practical experience with coding patterns through targeted MCQs and coding problems, designed to match and challenge your expertise level.
System Design
YouTubeFree Interview
Learn to design a video streaming platform like YouTube by tackling functional and non-functional requirements, core components, and high-level to detailed design challenges.

Free Resources

Copyright ©2025 Educative, Inc. All rights reserved