Skip to main content

Computational Problem Solving with Java and Interactive Object Graphics

Mark F. Russo, PhD

Section 4.4 Variable Scope and Lifetime

The scope of a Java variable refers to the region of the program where the variable can be accessed and used. Think of how a telescope or microscope both enhances but also limits what we can see. The lifetime of a variable, on the other hand, refers to the period during which the variable exists in memory.
Java has several levels of variable scope, the most important of which are as follows. We’ve encountered class scope and method scope already.
  1. package scope (limited to a Java package).
  2. class scope (accessible throughout a class), and
  3. object (instance) scope (limited to a specific object),
  4. method scope (limited to a specific method),
  5. block scope (limited to a specific block of code),
Class variables, also known as static variables, are declared within a class and associated with the class itself rather than with specific instances of the class. We refer to this as class scope. Variables and methods declared using the static keyword exist within the scope of the class within which it is declared. Static variables have lifetimes that are as long as the class exists, which is for the entire time that a program is running.
Explicitly accessing a static variable or method defined within a given class is accomplished using the class name followed by the dot-operator. Often, it is not necessary to specify the class scope when accessing a class-scope variable due to the way Java finds and binds an identifier to its declaration, but it never hurts to be explicit. Let’s consider an example.
Imagine that you’ve been asked to write a class called Counter to track of the number of people currently in a seminar room. Each time a person enters the room an enter() method is invoked and a total counter variable is incremented. When a person leaves, an exit() method is invoked which decrements the total counter variable. The total variable must be accessible to all methods within the class and it must have a lifetime that lasts for as long as the class. Declaring total as static within the class but outside all methods would ensure that these requirements are satisfied.
Consider the following short program implementing the Counter class in Listing 4.4.1. Note that a main() method is added to test the Counter class. The total variable is a long that is declared using the static keyword within the class but outside any of the class methods. This ensures that the variable has class scope, is accessible from all locations within the program, and will exist for the lifetime of the program.
The Counter class implements enter(), exit(), and reset() methods, which are used to manage the value of the total variable. When we access the total variable we precede it with the name of the class, for example Counter.total. This ensures that we are accessing the variable declared within the class scope. We also invoke class methods with a similar explicit setting of class scope, namely, Counter.enter() and Counter.exit(). While you will find that this explicit scoping is not always necessary, it helps to use it to communicate our intention.
Following Listing 4.4.1 we demonstrate what happens when the program is tested. A total of five people enter the room and three exit, leaving two people remaining in the room.
// Counter.java

// Counter counts people entering and exiting a room
class Counter {
    // Total count declared within the class but outside all methods
    public static long total = 0L;

    // Increment total count
    public static void enter() {
        Counter.total += 1L;
    }
    // Decrement total count
    public static void exit() {
        Counter.total -= 1L;
    }
    // Reset counter
    public static void reset() {
        Counter.total = 0L;
    }
    // Test the Counter class
    public static void main(String[] args) {
        Counter.enter();    // Person enters 
        Counter.enter();    // Person enters 
        Counter.enter();    // Person enters 
        Counter.enter();    // Person enters 
        Counter.exit();     // Person exits 
        Counter.enter();    // Person enters 
        Counter.exit();     // Person exits 
        Counter.exit();     // Person exits 

        // How many people are left in the room?
        System.out.println("There are " + Counter.total 
                            + " people remaining in the room");
    }
}
Listing 4.4.1. 
javac Counter.java 
java Counter
There are 2 people remaining in the room
By contrast, a variable is scoped to a method when it is declared within the method. It comes into existence when the method is entered and the declaration is executed, and it goes out of existance when the method completes. A method-scoped variable has a lifetime equal to the lifetime of method execution, and naturally, it cannot be accessed from any statement that is outside the method, because the method would no longer be executing.
For an example of method-scoped variables, we can refer back to nearly any of the past programs we’ve studied. For example, refer back to the updated ComputeDistance class in Listing 3.2.2. The distanceBetween(…) method declares several variables that are used within that method only, including term1, term2, and distance. These variables have method scope because they are declared within the distanceBetween(…) method and they are destroyed when the method returns (stops executing). They cannot be accessed from outside the method after its exits because they do not exist at that point.
We will introduce the remaining important Java scopes at a suitable time. Understanding variable scope and lifetime is crucial for managing memory efficiently, preventing naming conflicts, and ensuring proper data encapsulation in Java programs.
<Prev^TopNext>