Static method in Java with Example

The static can be:

1. Static Variables
2. Static Methods
3. Static Blocks Of Code.

Let’s look at static variables and static methods first.

Static variable in Java is variable which belongs to the class and initialized only once at the start of the execution. It is a variable which belongs to the class and not to object(instance ). Static variables are initialized only once, at the start of the execution. These variables will be initialized first, before the initialization of any instance variables.

• A single copy to be shared by all instances of the class
• A static variable can be accessed directly by the class name and doesn’t need any object

Syntax:

<class-name>.<variable-name>

Static method in Java is a method which belongs to the class and not to the object. A static method can access only static data. It is a method which belongs to the class and not to the object(instance). A static method can access only static data. It cannot access non-static data (instance variables).

• A static method can call only other static methods and can not call a non-static method from it.
• A static method can be accessed directly by the class name and doesn’t need any object
• A static method cannot refer to “this” or “super” keywords in anyway

Syntax:

<class-name>.<method-name>

Note: main method is static, since it must be accessible for an application to run, before any instantiation takes place.

Lets learn the nuances of the static keywords by doing some excercises!

Example: How to call static variables & methods

Step 1) Copy the following code into a editor

public class Demo{ public static void main(String args[]){ Student s1 = new Student(); s1.showData(); Student s2 = new Student(); s2.showData(); //Student.b++; //s1.showData(); } } class Student { int a; //initialized to zero static int b; //initialized to zero only when class is loaded not for each object created. Student(){ //Constructor incrementing static variable b b++; } public void showData(){ System.out.println("Value of a = "+a); System.out.println("Value of b = "+b); } //public static void increment(){ //a++; //} }

Step 2) Save & Compile the code. Run the code as, java Demo.

Step 3) Expected output show below

Following diagram shows, how reference variables & objects are created and static variables are accessed by the different instances.

Step 4) It is possible to access a static variable from outside the class using the syntax ClassName.Variable_Name. Uncomment line # 7 & 8 . Save , Compile & Run . Observe the output.

Value of a = 0 Value of b = 1 Value of a = 0 Value of b = 2 Value of a = 0 Value of b = 3

Step 5) Uncomment line 25,26 & 27 . Save , Compile & Run.

error: non-static variable a cannot be referenced from a static context a++;

Step 6) Error = ? This is because it is not possible to access instance variable “a” from java static class method “increment“.

The static block is a block of statement inside a Java class that will be executed when a class is first loaded into the JVM. A static block helps to initialize the static data members, just like constructors help to initialize instance members.

class Test{ static { //Code goes here } }

Following program is the example of java static block.

Example: How to access static block

public class Demo { static int a; static int b; static { a = 10; b = 20; } public static void main(String args[]) { System.out.println("Value of a = " + a); System.out.println("Value of b = " + b); } }

you will get following output of the program.

Value of a = 10 Value of b = 20

Static keyword can be used with class, variable, method and block. Static members belong to the class instead of a specific instance, this means if you make a member static, you can access it without object. Let’s take an example to understand this:

Here we have a static method myMethod(), we can call this method without any object because when we make a member static it becomes class level. If we remove the static keyword and make it non-static then we must need to create an object of the class in order to call it.

Static members are common for all the instances(objects) of the class but non-static members are separate for each instance of class.

class SimpleStaticExample { // This is a static method static void myMethod() { System.out.println("myMethod"); } public static void main(String[] args) { /* You can see that we are calling this * method without creating any object. */ myMethod(); } }

Output:

myMethod

Static Block

Static block is used for initializing the static variables.This block gets executed when the class is loaded in the memory. A class can have multiple Static blocks, which will execute in the same sequence in which they have been written into the program.

Example 1: Single static block

As you can see that both the static variables were intialized before we accessed them in the main method.

class JavaExample{ static int num; static String mystr; static{ num = 97; mystr = "Static keyword in Java"; } public static void main(String args[]) { System.out.println("Value of num: "+num); System.out.println("Value of mystr: "+mystr); } }

Output:

Value of num: 97 Value of mystr: Static keyword in Java

Example 2: Multiple Static blocks

Lets see how multiple static blocks work in Java. They execute in the given order which means the first static block executes before second static block. That’s the reason, values initialized by first block are overwritten by second block.

class JavaExample2{ static int num; static String mystr; //First Static block static{ System.out.println("Static Block 1"); num = 68; mystr = "Block1"; } //Second static block static{ System.out.println("Static Block 2"); num = 98; mystr = "Block2"; } public static void main(String args[]) { System.out.println("Value of num: "+num); System.out.println("Value of mystr: "+mystr); } }

Output:

Static Block 1 Static Block 2 Value of num: 98 Value of mystr: Block2

Java Static Variables

A static variable is common to all the instances (or objects) of the class because it is a class level variable. In other words you can say that only a single copy of static variable is created and shared among all the instances of the class. Memory allocation for such variables only happens once when the class is loaded in the memory.
Few Important Points:

• Static variables are also known as Class Variables.
• Unlike non-static variables, such variables can be accessed directly in static and non-static methods.

Example 1: Static variables can be accessed directly in Static method

Here we have a static method disp() and two static variables var1 and var2. Both the variables are accessed directly in the static method.

class JavaExample3{ static int var1; static String var2; //This is a Static Method static void disp(){ System.out.println("Var1 is: "+var1); System.out.println("Var2 is: "+var2); } public static void main(String args[]) { disp(); } }

Output:

Var1 is: 0 Var2 is: null

Example 2: Static variables are shared among all the instances of class

In this example, String variable is non-static and integer variable is Static. As you can see in the output that the non-static variable is different for both the objects but the static variable is shared among them, thats the reason the changes made to the static variable by object ob2 reflects in both the objects.

class JavaExample{ //Static integer variable static int var1=77; //non-static string variable String var2; public static void main(String args[]) { JavaExample ob1 = new JavaExample(); JavaExample ob2 = new JavaExample(); /* static variables can be accessed directly without * any instances. Just to demonstrate that static variables * are shared, I am accessing them using objects so that * we can check that the changes made to static variables * by one object, reflects when we access them using other * objects */ //Assigning the value to static variable using object ob1 ob1.var1=88; ob1.var2="I'm Object1"; /* This will overwrite the value of var1 because var1 has a single * copy shared among both the objects. */ ob2.var1=99; ob2.var2="I'm Object2"; System.out.println("ob1 integer:"+ob1.var1); System.out.println("ob1 String:"+ob1.var2); System.out.println("ob2 integer:"+ob2.var1); System.out.println("ob2 STring:"+ob2.var2); } }

Output:

ob1 integer:99 ob1 String:I'm Object1 ob2 integer:99 ob2 STring:I'm Object2

For more details on refer: Java – static variable

Java Static Methods

Static Methods can access class variables(static variables) without using object(instance) of the class, however non-static methods and non-static variables can only be accessed using objects. Static methods can be accessed directly in static and non-static methods.

Syntax:

Static keyword followed by return type, followed by method name.