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 Resources

Copyright ©2025 Educative, Inc. All rights reserved