Java Scope and Lifetime of Variables – Block, Method, and Class Scope

Understanding the scope and lifetime of variables in Java is crucial for writing efficient, bug-free, and maintainable code. Scope defines where a variable can be accessed, while lifetime defines how long it exists in memory.

🔍 What is Variable Scope?

Variable scope determines the visibility and accessibility of a variable within a program. In Java, scope is controlled by curly braces {} which define blocks of code.

Types of Scope in Java

Block Scope
Method Scope
Class Scope (Instance and Static Variables)

✅ Block Scope

A variable declared inside a block {} is accessible only within that block.

Example:

public class BlockScopeExample {
    public static void main(String[] args) {
        if (true) {
            int x = 10; // Block-scoped variable
            System.out.println("x inside block: " + x);
        }
        // System.out.println(x); // ❌ Compile error: x not visible here
    }
}

✅ Method Scope

Variables declared inside a method are called local variables. They are created when the method starts and destroyed when the method ends.

Example:

public class MethodScopeExample {
    public void greet() {
        String message = "Hello Java"; // Method-scoped variable
        System.out.println(message);
    }
}

✅ Class Scope

Variables declared at the class level have class scope. These can be either:

Instance Variables – Belong to individual objects.
Static Variables (Class Variables) – Shared across all instances of the class.

Example:

public class ClassScopeExample {
    int instanceVar = 5;         // Instance variable
    static int staticVar = 10;   // Static variable

    public void display() {
        System.out.println(instanceVar); // Accessible to all methods
        System.out.println(staticVar);   // Accessible using class name as well
    }
}

🧠 Lifetime of Variables

Variable Type	Created	Destroyed
Block Variables	When block is entered	When block exits
Method Variables	When method is invoked	When method ends
Instance Variables	When object is created	When object is garbage collected
Static Variables	When class is loaded into memory	When program terminates

🚫 Common Mistakes

Accessing block variables outside their block.
Relying on uninitialized local variables.
Overusing static variables causing memory retention.

💡 Best Practices

Keep variable scope as narrow as possible.
Initialize variables at the point of declaration.
Use class variables only when data needs to be shared across all objects.

🧩 Interview Relevance

Q: What is the difference between scope and lifetime of a variable?
A: Scope defines where a variable is accessible; lifetime defines how long it exists in memory.
Q: Can you access a local variable outside its method?
A: No, local variables are method-scoped.
Q: What happens to static variables when multiple objects are created?
A: Static variables are shared, so all objects refer to the same copy.

📌 Java Version Relevance

Java 1.0 introduced basic scope and lifetime rules.
Java 8 added lambda expressions which introduced effectively final variables in block scope.

✅ Summary

Block Scope: Variables exist within {} only.
Method Scope: Local variables exist only during method execution.
Class Scope: Instance and static variables live as long as the object or program.