Java provides a special type of member which doesn’t depend on the instance of a class.

These members execute independently without using class instance.

To create such members Java supports a static keyword that allows them to get executed before object creation.

A Static keyword can be imposed on both methods and variables.

The main method is a classic example of a static keyword that doesn’t need to the object for execution instead it runs before an instance is created.

How to access static variable or method ?

To access a static variable or to invoke a static method dot operator is used with the class name to which that particular variable or method belongs.

Points to remember:

• Only a single copy is created and used in case of static variable
• An object is not needed to access static variable and method
• Run before the creation of an object
• We can’t declare constructors as static
• A class cannot be declared as static, though Java allows an inner class to be defined as static
• Using static with the final keyword on a variable, create constant

Static keyword can be used with:

1. Variables
2. Methods
3. Blocks or initializers
4. Inner class

static dataType variableName;

static return_type method_name(){ 
//body 
}

public class Test
{				//Static variable 
  static int y;
    Test ()
  {
    System.out.println ("Hi!I am constructor");
  }				// Static method to access static variable 
  static void example ()
  {
    y = 10;
    System.out.println ("Hi! I am static and can access static variable =" +
      y);
  }
  public static void main (String[]args)
  {
    Test obj = new Test ();
    Test.example ();
  }

}

Hi!I am constructor
Hi! I am static and can access static variable = 10

static{ 
//static variable initializer 
}

public class Test
{
  //Static variable 
  static int y;
    Test ()
  {
    System.out.println ("Hi!I am constructor");
  }				// Static block to initialize variable 
  static
  {
    y = 10;
    System.out.println ("I am static Initializer = " + y);
  }
  public static void main (String[]args)
  {
    Test obj = new Test ();
  }

}

I am static Initializer = 10
Hi!I am constructor

• Java Static Nested Class with example

There is a concept of nested class which can be defined as a class when declared within another class is known as a nested class and when this nested class is preceded with a static keyword then it is said to be a static nested class.

In other words, a static nested class is a static member of the outer class.

It doesn’t require to wait for the instantiation of an object of the outer class which means we can create an object of static inner class independently.

• A static nested class can have static or nonstatic members.
• A static member of an outer class can be accessed by the methods of static inner class whereas non-static can’t be accessed directly. However, it can be possible by using the reference of the outer class.

Syntax:

class A
{
  static class B
  {
      
  }

}

Java program to show the working of static nested class:

public class Test
{

  //Static variable 
  static int y;
  // constructor 
    Test ()
  {
    System.out.println ("Hi!I am constructor");
  } static class nestedClass
  {
    void display ()
    {
      System.out.println ("I am from static nested class");
    }

  }
  public static void main (String[]args)
  {
    Test obj = new Test ();
    Test.nestedClass o = new Test.nestedClass ();
    o.display ();
  }

}

Output:

Hi!I am constructor
I am from static nested class

Java Program to demonstrate Working of static keyword

Program:

class Test
{

  static int y;			//Static variable 

    Test ()			// constructor 
  {
    System.out.println ("Hi!I am constructor");
  }

  static class nestedClass	//Nested static class 
  {
    void display ()
    {
      System.out.println ("I am from static nested class");
    }

  }

  // Static block to initialize variable static

  {
    y = 10;
    System.out.println ("I am static Initializer = " + y);
  }

  static void example ()	// Static method to access static variable 
  {
    y = 10;
    System.out.println ("Hi! I am static and can access static variable =" +
      y);
  }
  public static void main (String[]args)
  {
    Test obj = new Test ();

    Test.nestedClass o = new Test.nestedClass ();	// object of inner class 
    Test.example ();
    o.display ();
  }

}

Output: