Variable lifetime refers to how long a variable exists during the execution of a Java program. While variable scope tells us where a variable can be accessed, lifetime tells us how long that variable or its associated state exists.
This distinction becomes especially important when working with local variables, instance variables, static variables, objects, methods, and memory management.
Scope vs Lifetime
These two concepts are closely related, but they are not the same thing. Consider a local variable inside a method.
public class Main {
static void calculate() {
int total = 500;
System.out.println(total);
}
}
The scope of total is the region where the variable can be accessed. Its lifetime is associated with the execution of the method invocation in which that local variable exists.
| Concept | Main Question |
|---|---|
| Scope | Where can I access the variable? |
| Lifetime | How long does the variable or associated state exist? |
Remember: Scope = where, while lifetime = how long.
Lifetime of a Local Variable
A local variable is declared inside a method, constructor, or block. Its lifetime is tied to the execution of the relevant method, constructor, or block.
public class Calculator {
static void calculate() {
int price = 500;
int quantity = 2;
int total = price * quantity;
System.out.println(total);
}
public static void main(String[] args) {
calculate();
}
}
When calculate() starts executing, its local variables are created as needed for that execution. When the method finishes, those local variables are no longer accessible.
If the method is called again, a new method execution takes place and new local variable state is created for that invocation.
Local Variable Lifetime Across Multiple Method Calls
Consider this example:
public class Counter {
static void showCount() {
int count = 1;
count++;
System.out.println(count);
}
public static void main(String[] args) {
showCount();
showCount();
}
}
Both method calls print 2. The local variable count does not continue its value from the first method call into the second call. Each invocation has its own local state.
A local variable does not remember its previous value between separate method invocations. If you need state to remain associated with an object or class, an instance or static variable may be more appropriate.
Lifetime of an Instance Variable
An instance variable belongs to an object. Therefore, its lifetime is associated with the lifetime of that object's state.
public class Student {
String name;
Student(String name) {
this.name = name;
}
public static void main(String[] args) {
Student student = new Student("Rahul");
System.out.println(student.name);
}
}
The object created by new Student("Rahul") contains the instance variable name. The variable is part of that object's state.
When an object is no longer reachable by the running program, it can eventually become eligible for garbage collection. At that point, the object and its instance state are no longer needed by the application.
Object Lifetime and Garbage Collection
Java uses automatic memory management. Developers normally do not manually free objects as they would in languages that require explicit memory deallocation.
public class Main {
public static void main(String[] args) {
Student student = new Student("Rahul");
student = null;
}
}
After student = null, the variable no longer refers to the Student object. If no other reachable reference points to that object, the object may become eligible for garbage collection.
The important word is eligible. Becoming unreachable does not mean that garbage collection happens immediately at that exact statement.
Do not think of null as "delete this object." It removes that particular reference to the object. The JVM's garbage collector determines when an unreachable object can be reclaimed.
Lifetime of a Static Variable
A static variable belongs to the class rather than to an individual object. Its lifecycle is therefore associated with the class being loaded and remaining in the JVM's runtime environment.
public class Counter {
static int count = 0;
static void increment() {
count++;
}
public static void main(String[] args) {
increment();
increment();
System.out.println(count);
}
}
The value of count is shared across the method calls because it is static. Calling increment() again operates on the same class-level variable rather than creating a new local variable each time.
Local, Instance, and Static Lifetime
| Variable | Associated With | Lifetime Concept |
|---|---|---|
| Local Variable | Method, constructor, or block execution | Associated with that execution |
| Instance Variable | Object | Associated with the object's lifetime |
| Static Variable | Class | Associated with the class being active in the JVM |
Local Variable Does Not Survive Method Completion
A common beginner misunderstanding is thinking that a local variable continues to exist with its previous value after a method finishes.
public class Main {
static void test() {
int number = 10;
System.out.println(number);
}
public static void main(String[] args) {
test();
test();
}
}
Each call to test() has its own local variable number. The second call does not continue the local variable from the first call.
Instance Variables Preserve Object State
Instance variables are different because their values remain part of an object while that object remains available.
public class Student {
int marks;
void addMarks() {
marks = marks + 10;
}
public static void main(String[] args) {
Student student = new Student();
student.addMarks();
student.addMarks();
System.out.println(student.marks);
}
}
The first method call changes the object's marks value. The second call starts with the updated value because both calls operate on the same Student object.
This is one of the most important practical differences between local and instance state.
Static Variables Preserve Shared State
Static variables can also preserve state between method calls, but the state belongs to the class and is shared rather than belonging to one particular object.
public class Counter {
static int count = 0;
static void increment() {
count++;
}
public static void main(String[] args) {
increment();
increment();
increment();
System.out.println(count);
}
}
The same static variable is updated by every call. After three calls, count contains 3.
Variable Lifetime and Garbage Collection
It is important to distinguish the lifetime of a variable from the lifetime of an object. A local reference variable can disappear when a method finishes, while the object it referred to may continue to exist if another reachable reference points to it.
public class Main {
static Student savedStudent;
static void createStudent() {
Student student = new Student("Rahul");
savedStudent = student;
}
}
The local variable student is associated with the execution of createStudent(). However, the Student object can remain reachable after the method finishes because savedStudent refers to it.
This example shows why saying "the local variable disappears, therefore the object is deleted" is incorrect.
Scope and Lifetime Are Not Always Identical
For beginner code, scope and lifetime often appear to end around the same time, but they represent different concepts and should not be treated as interchangeable.
A variable can become inaccessible because its scope has ended, while an object associated with that variable may still remain alive because another reference can reach it.
Professional Java developers think separately about variable visibility, object reachability, and memory management. This distinction becomes increasingly important when applications become larger.
Common Beginner Mistakes
- Thinking scope and lifetime mean exactly the same thing.
- Assuming a local variable keeps its previous value after a method finishes.
- Thinking setting a reference to null immediately destroys an object.
- Assuming garbage collection happens immediately when an object becomes unreachable.
- Confusing an object's lifetime with the lifetime of a reference variable pointing to it.
Best Practices
Choose the appropriate variable type based on how long the data needs to remain part of your program's state. Temporary calculations usually belong in local variables, object-specific state belongs in instance variables, and genuinely shared class-level state can be represented using static variables.
public class Product {
String name;
static int totalProducts = 0;
void calculatePrice() {
int discount = 100;
System.out.println(discount);
}
}
In this example, name represents object-specific state, totalProducts represents shared class-level state, and discount is temporary method-level data.
Interview Insight
If an interviewer asks, "What is variable lifetime in Java?", a strong answer is: Variable lifetime refers to the period during which a variable or its associated state exists during program execution. Local variables are associated with method or block execution, instance variables with objects, and static variables with class-level runtime state.
If asked about garbage collection, remember that an object becomes eligible for garbage collection when it is no longer reachable from the running application. The JVM decides when the object is actually reclaimed.
Quick Revision
| Concept | Key Point |
|---|---|
| Lifetime | Describes how long a variable or associated state exists. |
| Local Variable | Associated with the execution of its method, constructor, or block. |
| Instance Variable | Part of an object's state and associated with that object's lifetime. |
| Static Variable | Represents class-level state shared by instances. |
| Object Reachability | Determines whether an object can still be reached by the running program. |
| Garbage Collection | Reclaims objects that are no longer reachable when the JVM determines it is appropriate. |
| Scope vs Lifetime | Scope means where; lifetime means how long. |
Variable lifetime becomes much easier to understand once you stop thinking of every variable as the same kind of storage. Local variables support temporary work, instance variables preserve the state of individual objects, and static variables maintain shared class-level state. Understanding these differences gives you a much clearer picture of how Java programs manage state during execution.