Understanding storage of static methods and static variables in Java

23 Mar, 2022
In every programming language, memory is a vital resource and is also scarce in nature. Hence it’s essential that the memory is managed thoroughly without any leaks. Allocation and deallocation of memory is a critical task and requires a lot of care and consideration. In this article, we will understand the storage of static methods and static variables in Java. Java Virtual Machine(JVM) is an engine that provides a run time environment to drive the java code. It converts the java byte code into machine language. The JVM has two primary functions. They are:
It allows java programs to run on any device or OS to fulfil WORA (Write Once Run Anywhere) principle.It manages and optimizes program memory.
It allows java programs to run on any device or OS to fulfil WORA (Write Once Run Anywhere) principle.
It manages and optimizes program memory.
The JVM memory manager creates memory pools during the runtime of the program. Let’s understand the concept of memory pools in java. There are two types of memory pools namely the stack memory and the heap memory. The main difference between stack memory and the heap memory is that the stack is used to store only the small datatypes whereas heap stores all the instances of the class. And, since java either implicitly or explicitly extends the class from Object.class, every class we create is a collection of objects. This also means that we cannot use a method or a variable unless we instantiate it with a new keyword. As soon as we instantiate the methods, JVM allocates some memory on the heap and it stores the address of the instance on the stack. After this, the methods and variables can be used. In order to get a better understanding of how the new keyword works, let’s take an example. Let’s take a bird class. Whenever a new bird is found, the number of birds need to be incremented. Let’s try to implement this code: 
Java
// Java program to demonstrate the above example public class Bird {    private String name;    private int number;     Bird(String name)    {        this.name = name;        number++;    }     public void fly()    {        System.out.println(            "This bird flies");    }     public int getNumber()    {        return number;    }     public String getName()    {        return name;    }} class GFG {    public static void main(String args[])    {        Bird b1 = new Bird("Parrot");        Bird b2 = new Bird("Sparrow");        Bird b3 = new Bird("Pigeon");         System.out.println(b1.getNumber());    }}
1
Clearly, this method cannot be used to count the number of birds because at every instance, a new heap is being allocated and for all the instances, the number of birds is being initialized from 0 and is incremented to 1. Therefore, we are creating three independent birds where, in every bird object, the number of birds is 1. In order to avoid this, we initialize the methods and variables as static. This means that the variable or method is not changed for every new object creation. Since these methods and variables cannot be stored in a normal heap, they are stored in a special area called permanent generation(PermGen).
The main difference is that the heap is the auto growing space, with RAM memory as its constraints, whereas this PermGen has a fixed space allocation, and this is shared with all the instances.
Let’s implement this by changing the number to a static variable. 
Java
// Java program to demonstrate the above example public class Bird {    private String name;    private static int number;     Bird(String name)    {        this.name = name;        number++;    }     public void fly()    {        System.out.println("This bird flies");    }     public int getNumber()    {        return number;    }     public String getName()    {        return name;    }} class GFG {    public static void main(String args[])    {        Bird b1 = new Bird("Parrot");        Bird b2 = new Bird("Sparrow");        Bird b3 = new Bird("Pigeon");         System.out.println(b1.getNumber());    }}
3
Note: In Java 5 and 6, PermGen space was used. But due to major changes in memory model in Java 8, storage specification has also been changed. Now a new memory space “MetaSpace” has been introduced where all the names fields of the class, methods of a class with the byte code of methods, constant pool, JIT optimizations are stored. The main reason for this change of PermGen in Java 8.0 is that it is tough to predict the size of PermGen, and it helps in improving garbage collection performance.
mayankdudeja17
java-JVM
memory-management
Static Keyword
Java
Write From Home
Java
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Object Oriented Programming (OOPs) Concept in Java
How to iterate any Map in Java
HashMap in Java with Examples
ArrayList in Java
Multidimensional Arrays in Java
Convert integer to string in Python
Convert string to integer in Python
How to set input type date in dd-mm-yyyy format using HTML ?
Python infinity
Factory method design pattern in Java