Variable Scope and Lifetime
Variable Scope and Lifetime in Java Programming Understanding the nature of a variable, its data type, object behavior, and its scope and lifetime are essential concepts for program use. This allows Java users to better understand how and when variables are accessible within a program, and how long they remain within the program’s execution process. The concepts of variable scope and lifetime in Java programs determine the role of a variable in a program by managing memory, processing, and storing data values.
Variable Scope in Java.
Scope in Java programs indicates the program scope or usage behavior of a variable, including how it is processed and accessible within the program. This determines where and how a declared program variable can be used, and where it can be modified if necessary. The scope of any programmer-declared variable depends on where in the program it is declared and for what purpose.
Key Variable Scope and Types in Java Programming.
Local Java Variable Scope.
A local variable in a Java program is declared or defined by the user within a method, constructor, or variable parameter block, and these declared local variables are accessed and used only within that particular method, constructor, or parameter block. Remember, local variables are not declared or accessed externally.
Elements of Local Variable Scope.
- Local Java Variable Visibility – The visibility of a local Java variable is limited to the user method or program parameter block where it is declared.
- Local Java Variable Lifetime – Local variables in a Java program are available only as long as the method or block in which they are executed is executing.
Local Java Variable Scope Example.
public class LocalVarScope {
public void testMethod() {
int p = 7; // Here, the local variable ‘p’ is accessible only inside this method.
System.out.println(“The value of variable p is – ” + p); // This will only work here.
}
public static void main(String[] args) {
LocalVarScope obj = new LocalVarScope();
obj.testMethod();
// Here, uncommenting the above line will cause a compile-time program error.
// System.out.println(“The value of variable p is – ” + p); // Display Error – here ‘p’ local variable cannot be accessed outside its defined scope
}
}
}
}
}
Local Java Variable Scope Explanation.
In this program, the local variable p is declared or defined inside testMethod(), and the declared p variable can only be accessed and used from within that method. If the programmer tries to access the p variable from outside its declaring method, it displays a compile-time error at runtime.
Instance Java Variable Scope.
In a Java program, an instance variable or field data type variable is declared or defined within a class, while a user-declared variable is associated with a single object outside of any program method or constructor, and can be accessed or used from any method within the user-declared class. It is also known as a class member variable.
Elements of Instance Java Variable Scope.
- Instance Variable Scope Visibility – Instance Java program variables can be accessed and used from anywhere by all methods and constructors in the declaring class.
- Instance Variable Scope Lifetime – Instance Java program variables remain active and available in a program, until they are garbage collected from the program.
Instance Java Variable Scope Example.
public class Employee {
String emp_name; // here the emp_name instance variable is declared as a string
/ here we use the constructor to initialize the instance variable in the class
public Employee(String emp_name) {
this.emp_name = emp_name;
}
public void info() {
System.out.println(“The employee name – ” + emp_name); // Here it can access the instance variable
}
public static void main(String[] args) {
Employee employee = new Employee(“Bhavishi”);
employee.info(); // Result is – Emp_Name – Bhavishi
}
}
Instance Java Variable Scope Explanation.
Here in this program, the instance variable name can be accessed and used from any method in the Employee class, such as info() and the constructor.
Class Variables Java Scope/Static Variables.
In a Java program, a class variable and a static variable are declared or defined with the static keyword. Java static program variables are shared by all instances of the declared class. Static Java variables refer to classes rather than specific objects.
Elements of Class Variables Java Scope/Static Variables.
- Static Variables Visibility – Static Java variables are accessible by all methods of the class, and can be accessed or processed using the same class name without an object instance.
- Static Variables Lifetime – A static variable remains available to the class as long as the class memory remains active or loaded, meaning until the JVM is completely shut down.
Java static class variable scope example.
public class Limiter {
static int limit = 0; // Here we declare the limit class variable as static
/ We create a method to increment the limit variable
public static void increment() {
limit++;
}
public static void main(String[] args) {
Limiter.increment();
System.out.println(“The limit is – ” + limit); // Result is – The limit is – 1
Limiter.increment();
System.out.println(“The limit is – ” + limit); // Result is – The limit is – 2
}
}
Static class variable scope explanation.
The static variable limit declared here in this program is shared by all instances of the Limiter class. It can also be accessed and used directly by the class name Limiter.limit, as it is accessed and used by the increment() method in this program.
Variable Lifetime is a Java concept.
The lifetime of a variable declared by a programmer in a Java program refers to the length of time a variable remains available in program memory. The lifetime of a variable declared in a Java program depends entirely on the class or method scope and how the variable is allocated within the program.
Local Variable Java Lifetime.
Local variables in a Java program are created when a method or block is executed.
Local variables are automatically destroyed when the execution of a method or block is complete.
Local variables declared in a program are stored on the stack and are automatically deleted when the program method or block is executed or terminates.
Local Variable Lifetime Example.
public class LocalVarLifetime {
public void testMethod() {
int localVariable = 4; // Here the Local variable is created
System.out.println(localVariable); // Here the variable ‘localVariable’ is alive or in use
} // Here the local variable is destroyed once the method execution and finalization are complete
public static void main(String[] args) {
LocalVarLifetime obj = new LocalVarLifetime();
obj.testMethod();
}
}
Local Variable Java Lifetime Explanation.
In this program, the local variable localVariable exists only during the class execution of testMethod(). When the program method ends, the local variable is destroyed.
Instance Variable Lifetime in Java.
When an object is instantiated in a Java program, it is declared using the new keyword.
When the object in the Java program is garbage collected, i.e., when no references to the object exist, it is destroyed.
Instance variables in a Java program are stored on the heap and are defined as portions of an object.
Instance Variable Lifetime Example.
public class Employee {
String emp_name; // declare the string instance variable here
public Employee(String emp_name) {
this.emp_name = emp_name; // initialize the instance variable here
}
public static void main(String[] args) {
Employee employee = new Employee(“Siddhi”); // Here the object was created, ’emp_name’ was initialized.
System.out.println(employee.emp_name); // Result is – Siddhi
}
} // Here the ’employee’ object will be garbage collected once it is no longer used.
Instance Variable Lifetime Explanation.
In this program, the emp_name instance variable remains available as long as the employee object is active or alive. This variable is terminated when the reference to the object in the program is terminated, and it becomes suitable for garbage collection.
Java lifetime of a class variable.
For statically declared variables, it is created when a Java program loads the class into memory.
This variable is destroyed when the JVM on your computer terminates, as static variables are part of a declared class definition.
In Java programs, user-declared class variables are stored and processed in a special memory area known as the method area or static memory.
Lifetime of a class variable example.
public class UniversalLimit {
static int limit = 0; // see the static limit variable created
public static void increment() {
limit++;
}
public static void main(String[] args) {
UniversalLimit.increment();
System.out.println(“The limit is – ” + limit);” // Resul – The limit is – 1
}
} // Here, the static variable ‘limit’ exists as long as the JVM is running on your system.
Lifetime of a class variable Explanation.
In this program, the UniversalLimit class is loaded by the JVM, and the static variable limit is created in it. This variable remains in memory for the entire lifetime of the JVM.
Detail explanation of Variable Scope and Lifetime in java.
| Variable Type | Java Variable Scope | Java Variable Lifetime | Variable Storage Location |
| Local Variable | Local variable Accessible and use only within the method or block where they are declared by programmer. | Java lifetime variable Created when method/block starts, it automatically destroyed when method/block ends in program. | Store in Stack location |
| Instance Variable | Java Instance variable Accessible only by all methods of the its class, align with the created object. | Instance variable lifetime Created when object is created, it destroyed when object is garbage collected in program. | Store In Heap location |
| Class Variable | Program class variable declares Accessible by all methods of the its class, even shared by all its objects. | Java variable lifetime Created when the class is loaded in program, it destroyed when JVM shuts down in your computer or machine. | Store in Method area (static memory) |
Accessing Java variables with different scopes.
Variable shadowing is used in Java programming when a local variable in a Java program has the same name as an instance or class variable. In such a case, the local Java variable shadows the instance or class variable within a method or block.
Example of Java variable shadowing.
public class ShadowIllustration {
int p = 7; // Instance variable created here
public void testMethod() {
int p = 9; // Here the local variable shadows the instance variable value
System.out.println(p); // Prints local p – 9
}
public static void main(String[] args) {
ShadowIllustration obj = new ShadowIllustration();
obj.testMethod();
}
}
Java variable shadowing explanation.
In this program, a local variable p in testMethod() shadows the instance variable p. Priority is given to the local variable p inside the program’s declared method, and the instance variable p is not used here.
