Lifetime of Variables in Java

The lifetime of a variable refers to the period during which the variable occupies memory and is accessible during the execution of a program. Understanding the lifetime of variables is crucial for effective memory management and avoiding common programming issues such as memory leaks and dangling pointers. The lifetime of a variable is determined by where and how it is declared. Variables in Java can be categorized into several types based on their scope and lifetime:

Local Variables
Instance Variables (Fields)
Class Variables (Static Fields)
Parameters
Block Variables

1. Local Variables

Local variables are declared inside a method, constructor, or block. They are created when the method, constructor, or block is entered, and destroyed when it is exited.

Lifetime:

Creation: When the method, constructor, or block is invoked.
Destruction: When the method, constructor, or block completes execution.

Scope:

Limited to the method, constructor, or block where they are declared.

Characteristics:

Not accessible outside the method, constructor, or block.
Must be initialized before use.

File Name: LocalVariableExample.java

 
 public class LocalVariableExample {
    public void display() {
        int localVariable = 10; // Local variable
        System.out.println("Local variable: " + localVariable);
    }
    public static void main(String[] args) {
        LocalVariableExample example = new LocalVariableExample();
        example.display();
        // Uncommenting the line below will cause a compile-time error
        // System.out.println(localVariable); // localVariable is not accessible here
    }
}  

Output:

 
Local variable: 10

2. Instance Variables (Fields)

Instance variables are declared in a class but outside any method, constructor, or block. They are associated with an instance of the class (an object).

Lifetime

Creation: When an instance of the class is created.
Destruction: When the instance is no longer referenced and is garbage collected.

Scope

Accessible by all methods, constructors, and blocks in the class.

Characteristics

Each instance of the class has its own copy of the instance variables.
Can have default values if not explicitly initialized.

File Name: InstanceVariableExample.java

 
public class InstanceVariableExample {
    int instanceVariable; // Instance variable
    public InstanceVariableExample(int value) {
        this.instanceVariable = value;
    }
    public void display() {
        System.out.println("Instance variable: " + instanceVariable);
    }
    public static void main(String[] args) {
        InstanceVariableExample example1 = new InstanceVariableExample(5);
        InstanceVariableExample example2 = new InstanceVariableExample(10);
        example1.display(); // Output: Instance variable: 5
        example2.display(); // Output: Instance variable: 10
    }
}   

Output:

 
Instance variable: 5
Instance variable: 10

3. Class Variables (Static Fields)

Class variables are declared with the static keyword inside a class but outside any method, constructor, or block. They belong to the class itself rather than any instance of the class.

Lifetime

Creation: When the class is loaded into memory.
Destruction: When the class is unloaded from memory (usually when the JVM terminates).

Scope

Accessible by all methods, constructors, and blocks in the class.
Can be accessed directly using the class name.

Characteristics

Only one copy of the class variable exists, regardless of the number of instances of the class.
Can be used to store data that is shared among all instances of the class.

File Name: ClassVariableExample.java

 
public class ClassVariableExample {
    static int classVariable; // Class variable
    public static void display() {
        System.out.println("Class variable: " + classVariable);
    }
    public static void main(String[] args) {
        ClassVariableExample.classVariable = 100;
        ClassVariableExample.display(); // Output: Class variable: 100
        ClassVariableExample example1 = new ClassVariableExample();
        ClassVariableExample example2 = new ClassVariableExample();
        example1.classVariable = 200;
        example2.display(); // Output: Class variable: 200
    }
}   

Output:

 
Class variable: 100
Class variable: 200

4. Parameters

Parameters are variables that are passed to methods, constructors, or blocks.

Lifetime

Creation: When the method, constructor, or block is invoked.
Destruction: When the method, constructor, or block completes execution.

Scope

Limited to the method, constructor, or block where they are declared.

Characteristics

Used to pass data to methods, constructors, or blocks.
Treated as local variables within the method, constructor, or block.

File Name: ParameterExample.java

 
public class ParameterExample {
    public void display(int parameter) { // Parameter
        System.out.println("Parameter: " + parameter);
    }
    public static void main(String[] args) {
        ParameterExample example = new ParameterExample();
        example.display(15); // Output: Parameter: 15
    }
}   

Output:

 
Parameter: 15

5. Block Variables

Block variables are declared inside a block, such as a loop or an if statement.

Lifetime

Creation: When the block is entered.
Destruction: When the block is exited.

Scope

Limited to the block where they are declared.

Characteristics

Not accessible outside the block.
Must be initialized before use.

File Name: BlockVariableExample.java

 
public class BlockVariableExample {
    public void display() {
        for (int i = 0; i < 5; i++) { // Block variable
            System.out.println("Block variable: " + i);
        }
        // Uncommenting the line below will cause a compile-time error
        // System.out.println(i); // i is not accessible here
    }
    public static void main(String[] args) {
        BlockVariableExample example = new BlockVariableExample();
        example.display();
    }
}   

Output:

 
Block variable: 0
Block variable: 1
Block variable: 2
Block variable: 3
Block variable: 4

Conclusion

Local Variables: Created and destroyed within a method, constructor, or block. Not accessible outside.

Instance Variables: Associated with an instance of the class. Created when the instance is created and destroyed when it is garbage collected.

Class Variables: Belong to the class itself. Created when the class is loaded and destroyed when the class is unloaded.

Parameters: Passed to methods, constructors, or blocks. Treated as local variables within the scope.

Block Variables: Declared within a block and not accessible outside it.

Next TopicMatrix-max-sum-path-problem-in-java

← prev next →

We provides tutorials and interview questions of all technology like java tutorial, android, java frameworks

Contact info

G-13, 2nd Floor, Sec-3, Noida, UP, 201301, India

[email protected].

Lifetime of Variables in Java

1. Local Variables

Lifetime:

Scope:

Characteristics:

2. Instance Variables (Fields)

Lifetime

Scope

Characteristics

3. Class Variables (Static Fields)

Lifetime

Scope

Characteristics

4. Parameters

Lifetime

Scope

Characteristics

5. Block Variables

Lifetime

Scope

Characteristics

Conclusion

Learn Important Tutorial

B.Tech / MCA

Preparation

Contact info

Follow us

Tutorials

Interview Questions

Online Compiler

Python

AI, ML and Data Science

Java

B.Tech and MCA

Web Technology

Software Testing

Technical Interview

Java Interview

Web Interview

Database Interview

Company Interviews

Java Tutorial

Control Statements

Java Object Class

Java Inheritance

Java Polymorphism

Java Abstraction

Java Encapsulation

Java Array

Java OOPs Misc

Java String

Java String Methods

Java Regex

Exception Handling

Java Inner Class

Java Multithreading

Java Synchronization

Java Networking

Java Applet

Java Reflection

Java Conversion

Java JDBC

RMI

Internationalization

Java Array Class

Java AtomicInteger Class

Java AtomicLong Methods

Java Authenticator

Java BigDecimal class

Big Integer Class

Java Boolean class

Java Byte Class

Java Class

Java Collections class

Java Compiler Class

CopyOnWriteArrayList

Java Math Methods

LinkedBlockingDeque

Java Long class

LinkedTransferQueue

Java List

Java MulticastSocket

Java Number Class

Java Phaser Class

ArrayList Methods

Java Thread Methods

Java Projects

Java Programs

Java Misc

Java Date Class

Java ListIterator Class

Java NIO Tutorial

HttpURLConnection

Java Deque

Java HttpCookie Class

Java URL class

Java List Methods

Java Vector class

Java Collection Methods

Java Socket Class

Java Executors

Java Integer Class

Java IdentityHashMap

Java ArrayBlockingQueue

Java Timestamp

Java Spliterator

Java Bitset

Java Instant

Lifetime of Variables in Java

1. Local Variables