The main purpose of static keyword in java is memory management.
The static keyword can be used in each of the five cases.
- static variables
- static methods
- static block
- static nested class
- Interface static method(java 8 onward)
- STATIC VARIABLES
In Java Variables can be declared with the “static” keyword.When a variable is declared with the keyword static, its called a class variable. All instances share the same copy of the variable. A class variable can be accessed directly with the class, without the need to create an instance.
Example: static int i = 0;
ADVANTAGE OF STATIC VARIABLE
It makes your program memory efficient (i.e it saves memory).
now let us execute a program without static variable.
Suppose there are 1500 students in a college, now all instance data members will get memory each time when object is created.All student have its unique rollno and name so instance data member is good.Here, college refers to the common property of all objects.if we don't use static keyword at the variable college then for all 1500 students the huge amount of memory space will be used which is not a good programming practice.
class Student{
int rollno;
String name;
String college="XYZ";
}
program using static variable
package com.brainatjava.test;
public class Student {
static String college ="XYZ";
int rollno;
String name;
Student(int r,String n){
rollno = r;
name = n;
}
void display (){
System.out.println(rollno+" "+name+" "+college);}
public static void main(String args[]){
Student s1 = new Student(10,"Rabi");
Student s2 = new Student(20,"Rohit");
s1.display();
s2.display();
}
}
10 Rabi XYZ
20 Rohit XYZ
- STATIC METHOD
Static Methods can access class variables without using object of the class. It can access non-static methods and non-static variables by using objects. Static methods can be accessed directly in static and non-static methods.
EXAMPLE OF STATIC METHOD
public class Test1 {
static int i =10;
//Static method
static void display()
{
//Its a Static method
System.out.println("i:"+Test1.i);
}
void foo()
{
//Static method called in non-static method
display();
}
public static void main(String args[]) //Its a Static Method
{
//Static method called in another static method
display();
Test1 t1=new Test1();
t1.foo();
}
}
OUTPUT
i:10
i:10
STATIC BLOCK
It is used to initialize the static data member.It is executed before main method at the time of classloading.A class can have multiple Static blocks, which will execute in the same sequence in which they have been written in the program.
EXAMPLE OF SINGLE STATIC BLOCK
public class ExampleOfStaticBlock {
static int i;
static String str;
static{
i =30;
str = "welcome to BrainAtJava";
}
public static void main(String args[])
{
System.out.println("Value of i="+i);
System.out.println("str="+str);
}
}
OUTPUT
Value of i=30
str=welcome to BrainAtJava
EXAMPLE OF MULTIPLE STATIC BLOCK
public class ExampleOfMultipleStaticBlock {
static int i1;
static int i2;
static String str1;
static String str2;
//First Static block
static{
i1 = 70;
str1 = "Hello";
}
//Second static block
static{
i2= 55;
str2 = "java";
}
public static void main(String args[])
{
System.out.println("Value of i1="+i1);
System.out.println("Value of str1="+str1);
System.out.println("Value of i2="+i2);
System.out.println("Value of str2="+str2);
}
}
OUTPUT
Value of i1=70
Value of str1=Hello
Value of i2=55
Value of str2=java
Static Nested Class:
A static nested class in Java is simply a class scoped within another class.We can think of it as the static members of the enclosing class.
We can access it without creating an instance of the outer class.Simple it can be accessed by outerclass.innerclass.We can follow the below example.
A static nested class in Java serves a great advantage to namespace resolution. For example, if we have a class with an common name, and in a large project, it is quite possible that some other programmer has the same idea, and has a class with the same name you had, then we can solve this name clash by making our class a
public static nested class. And our class
will be written as outer class, followed by a period (.) and then
followed by static nested class name.Let's take an example
class Outernormal
{
private int var = 20;
private static int staticVar = 50;
public static void staticmethod(){
System.out.println(var);//Error: Cannot make a static reference to the non-static field mem
System.out.println(staticVar);
}
static class InnerStatic
{
public void getFields ()
{
System.out.println(var); //Error: Cannot make a static reference to the non-static field mem
System.out.println(staticVar);
}
}
}
public class StaticClassDemo
{
public static void main(String[] args)
{
OuterStatic.InnerStatic is = new OuterStatic.InnerStatic();
is.getFields();
}
}
Interface static method(java 8 onward):
In Java8 onwards , we can define static methods in interface ,but we can’t override them in the implementation classes.
This helps us in avoiding undesired results in case of wrong implementation of interface.
It is good for providing utility methods,for example any precondition check.
It provides security by not allowing implementing classes to override them.
Let's see code sample below.
public interface MyInf {static boolean checkIfNull(String str) {
System.out.println("Interface Null Check");
return str == null ? true : false;
}
}
