Where are static methods and variables stored in…

Static methods and class variables are stored in an area of memory called the Method Area (also known as Non-Heap Memory or Permanent Generation in older JVM versions, and as Metaspace in Java 8+). This memory area is allocated for storing class-level data, not instance-level data.

Here is a more detailed description:

Method Area: This is the central place for storing class information, including bytecode of methods, static variables, constants, constructor information, and other class metadata. This memory area is shared among all threads in the JVM.
Static Variables:
- There is only one copy of a static variable for the entire class, regardless of how many objects of this class are created.
- They are initialized when the class is loaded into the JVM.
Static Methods:
- They cannot directly access non-static members of the class (since they are not tied to a specific object instance).
- They can be called without creating an instance of the class, using the class name.

Example:

// Example class with static members
public class Example {
    // Static variable stored in Method Area
    static int staticVariable = 10;

    // Static method stored in Method Area
    public static void staticMethod() {
        System.out.println("This is a static method.");
    }

    // Non-static variable stored in heap memory for each object
    int instanceVariable = 20;

    // Non-static method stored in heap memory for each object
    public void instanceMethod() {
        System.out.println("This is an instance method.");
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        // Access static variable and method via class name
        System.out.println(Example.staticVariable); // Outputs 10
        Example.staticMethod(); // Outputs "This is a static method."

        // Creating an object instance (object stored in heap memory)
        Example obj1 = new Example();
        System.out.println(obj1.instanceVariable); // Outputs 20
        obj1.instanceMethod(); // Outputs "This is an instance method."
    }
}

Comparison table of static and non-static members:

Characteristic	Static Members	Non-Static Members
Location	Method Area (Metaspace/PermGen)	Heap memory (per object)
Number	One copy for the entire class	One copy per object
Access	Via class name or object (not recommended)	Via object instance
Object relation	Not tied to a specific object	Tied to a specific object
Initialization	When the class is loaded	When the object is created

Thus, static class members are located in the Method Area, separated from the heap memory where object instances are stored.

Where are static methods and variables stored in Java?