The Scope and Life time of Variables

So far, all of the variables that we have been using were declared at the start of the main( ) method. However, Java allows variables to be declared within any block. As explained in Module 1, a block is begun with an opening curly brace and ended by a closing curly brace. A block defines as cope. Thus, each time you start a new block, you are creating a new scope. A scope determines what objects are visible to other parts of your program. It also determines the lifetime of those objects. Most other computer languages define two general categories of scopes: global and local. Although supported by Java, these are not the best ways to categorize Java’s scopes. The most important scopes in Java are those defined by a class and those defined by a method. A discussion of class scope(and variables declared with in it) is deferred until later in this Site, when classes are described. For now, we will examine only the scopes defined by or within a method. The scope defined by a method begins with its opening curly brace. However, if that method has parameters, they too are included within the method’s scope. As a general rule, variables declared inside a scope are not visible (that is, accessible) to code that is defined outside that scope. Thus, when you declare a variable within a scope, you are localizing that variable and protecting it from unauthorized access and/or modification. Indeed, the scope rules provide the foundation for encapsulation. Scopes can be nested. For example, each time you create a block of code, you are creating a new, nested scope. When this occurs, the outer scope encloses the inner scope. This means that objects declared in the outer scope will be visible to code within the inner scope.However, the reverse is not true. Objects declared within the inner scope will not be visible outside it. To understand the effect of nested scopes, consider the following program:

// Demonstrate block scope. 

class ScopeDemo 
{
 public static void main(String args[]) 
{ 
int x;
 // known to all code within main
x = 10; 
if(x == 10) 
{ 
// start new scope
int y = 20; 
// known only to this block
// x and y both known here.

System.out.println("x and y: " + x + " " + y); 

x = y * 2;

}

 //

 y = 100;

 // Error! y not known here

// x is still known here. 

System.out.println("x is " + x);

}

}

As the comments indicate, the variable xis declared at the start of main( )’s scope and is accessible to all subsequent code with in main( ). Within the if block, y is declared. Since a block defines a scope,y is visible only to other code within its block. This is why outside of its block, the line y = 100;is commented out. If you remove the leading comment symbol, a compile-time error will occur, because y is not visible outside of its block. Within the if block, x can be used because code within a block (that is, a nested scope) has access to variables declared by an enclosing scope. Within a block, variables can be declared at any point, but are valid only after they are declared. Thus, if you define a variable at the start of a method, it is available to all of the code within that method. Conversely, if you declare a variable at the end of a block, it is effectively useless, because no code will have access to it. Here is another important point to remember: 

variables are created when their scope is entered, and destroyed when their scope is left. This means that a variable will not hold its value once it has gone out of scope. Therefore, variables declared within a method will not hold their values between calls to that method. Also, a variable declared within a block will lose its value when the block is left. Thus, the lifetime of a variable is confined to its scope. If a variable declaration includes an initializes, that variable will be reinitialized each time the block in which it is declared is entered. For example, 

consider this program:

// Demonstrate lifetime of a variable. 

class VarInitDemo 

{

 public static void main(String args[]) 

{ 

int x;

for(x = 0; x < 3; x++) 

{

 int y = -1; 

// y is initialized each time block is entered 

System.out.println("y is: " + y); 

// this always prints -1 

y = 100; 

System.out.println("y is now: " + y); }

}

}

The output generated by this program is shown here:

y is:                -1 

y is now:      100 

y is:                -1 

y is now:      100 

y is:                -1 

y is now:      100

As you can see,y is always reinitialized to –1 each time the inner for loop is entered. Even though it is subsequently assigned the value 100, this value is lost. There is one quirk to Java’s scope rules that may surprise you: although blocks can be nested, no variable declared within an inner scope can have the same name as a variable declared by an enclosing scope. For example, the following program, which tries to declare two separate variables with the same name, will not compile.

/*

This program attempts to declare a variable in an inner scope with the same name as one defined in an outer scope.

*** This program will not compile. ***

*/ 

class NestVar 

{ 

public static void main(String args[]) 

{

 int count;

for(count = 0; count < 10; count = count+1) 

{

 System.out.println("This is count: " + count);

int count;

 // illegal!!! 

for(count = 0; count < 2; count++)

 System.out.println("This program is in error!");

}

}

}

If you come from a C/C++ background, you know that there is no restriction on the names that you give variables declared in an inner scope. Thus, in C/C++ the declaration of count with in the block of the outer for loop is completely valid, and such a declaration hides the outer variable. The designers of Java felt that this name hiding could easily lead to programming errors and disallowed it.