Local variables (in a method)

Local variables

Local variable:

How to the define a local variable:

A local variable is defined inside the body of a method

(I.e., a local variable is defined between the opening and closing braces of a method)

Example:

public class MyProgram { public static void main(String[] args) { // Body of method "main" double r; // *** Local variable !!! r = MyProgran.min( 1.0, 4.0 ); System.out.println(r); r = MyProgram.min( 3.7, -2.9 ); System.out.println(r); r = MyProgram.min( -9.9, 3.8 ); System.out.println(r); } }
public class ToolBox { public static double min ( double a, double b ) { // Body of method "min" double m = 0; // *** Local variable !!! if ( a < b ) { m = a; // a is the smaller value } else { m = b; // b is the smaller value } return(m); } }

Next, we study the life time and the scoping rules for local variables

The life time of variables

Kinda like animals, variables in a computer program has a life time:

A variable is created ("born") at a certain moment
It exists for some time while the computer program is executing....
And then the variable ceases to exist

Previously discussed:

A variable in a running computer program is in fact a memory cell (See: click here )
Creating a variable = reserve memory space for a variable (See: click here )

Computer Science Jargon:

Destroying a variable = reclaim the reserved memory space occupied by a variable
When the reserved memory space taken up by a variable is reclaimed, that variable will cease to exist

Definition: the life time of a variable:

The life time of a local variable
- Moment of creation (of a local variable):
- Moment of destruction (of a local variable):

Example: how local variables are created and destroyed

Consider the following program:
When the program starts to run, the RAM memory contains only the program instructions:

The program starts to run with the main method.

The current program location is given by a green arrow:

Note:

There are 2 dark green arrows in the figure.
The arrow in the left figure points to the current program location in the human readable Java program
The Java program must be compiled (translated) into machine instruction to be executed.
The arrow in the right figure points to the current program location in the machine instructions program

Here is how the local variables are created and destroyed:

When the computer encounters the definition of the local variable r, it creates it in RAM (in other words: reserve memory to hold the value)
When the computer executes the method call, the program execution is transfered , to the min method:

When the computer encounters the definition of the local variable r, it creates it in RAM (in other words: reserve memory to hold the value)

How is scoping rules used in a programming langauge?
- When you use a variable name in a program, the scoping rules will determine if that variable name can be legally used.
- When you define multiple variables of the same name, the scoping rules will determine if that is allowed and if so, which variable is referenced by that name.
- Analogy:
  - Variable name = person name
  - Location in program = geographical area
  - Scoping rules determines "which variable" (which person) will be refered to by that name in a given "location in the program" (in a given geographical area)
- So we need a way to delimit a region of the program - this is a block (a "neighborhood" if you want to stick to the analogy).

Block

A block is a region inside a method that starts with a { and ends with a }

Example:

public class FindFactors { public static void main(String[] args) { // <----- start block 1 Scanner in = new Scanner(System.in); int n; int f; System.out.print("Enter integer: "); n = in.nextInt(); f = 2; // start while ( n != 1 ) { // <----- start block 2 if ( n % f == 0 ) { // <----- start block 3 System.out.println(f); n = n / f; } // <----- end block 3 else { // <----- start block 4 f++; // Try next number } // <----- end block 4 } // <----- end block 2 } // <----- end block 1 }

The following is an "abstracter" view of the blocks in the above example:
As you can see in the example, a block can be contained in another block:
- Block 1 contains block 2
- Block 1 contains block 3
- Block 1 contains block 4
- Block 2 contains block 3
- Block 2 contains block 4
When one block contains another block, there is an overlap between 2 blocks.
Notice that block 3 and block 4 are non-overlapping blocks !

Scope of a local variable

So far, I have always defined local variables (that can only be defined inside a method) at the start of the method
I did this to delay the discussion on scope rules for local variables.
In Java (and many modern languages), you can define new variables any where inside a method.
When you do this, there are consequences about where you can access the variable
(A local variable defined at the start of a method is accessing everywhere inside the method - that's why I don't need to talk about scoping rules until now....)
Remember that:
IMPORTANT

Example:

public class FindFactors { public static void main(String[] args) { // <----- start block 1 Scanner in = new Scanner(System.in); int n; int f; System.out.print("Enter integer: "); n = in.nextInt(); f = 2; while ( n != 1 ) { // <----- start block 2 if ( n % f == 0 ) { // <----- start block 3 System.out.println(f); n = n / f; } // <----- end block 3 else { // <----- start block 4 f++; // Try next number } // <----- end block 4 } // <----- end block 2 } // <----- end block 1 }

The scope of the local variables n and f extends from where they are defined to the end of method main() (at the line "<----- end block 1")
When you use blocks to represent the scopes as in this figure:
You can see that the scope of these variables is the "yellow" rectangle".
The other rectangles are contained inside the "yellow" rectangle" - these variable are accessible inside its rectangle (the "yellow" rectangle") and all rectangles that is contained in the "yellow" rectangle".

Application of the Scope of a local variable: identification

Consider this example:

public class RectangleTester { public static double area(Rectangle rect) { // <---- Start block 1 double r = rect.getWidth() * rect.getHeight(); // (1) return r; } // <---- End block 1 public static void main(String[] args) { // <---- Start block 2 Rectangle r = new Rectangle(5, 10, 20, 30); //(2) double a = area(r); System.out.println(r); }// <---- End block 2 }

The scope of the variable double r extends from where r is defined (line (1)) to the end of the enclosing block (end of block 1)
So when a variable named r is mentioned inside this range, Java will identify the name r with the variable double r (because that's where this variable is accessible)
The scope of the variable Rectangle r extends from where r is defined (line (2)) to the end of the enclosing block (end of block 2)
So when a variable named r is mentioned inside this range, Java will identify the name r with the variable Rectangle r (because that's where this variable is accessible)

Application of the Scope of a local variable: identification 2

Consider this example:

public class Scoping1 { public static void main(String[] args) { int i = ...; if ( i > 15 ) { int j = 20; // (A) System.out.println(j); // (1) } else { String j = "Hello"; // (B) System.out.println(j); // (2) } System.out.println(j); // (3) } }

There are 3 places in the program where the variable j is used - these locations are marked red.
There are 2 places in the program where the variable j is defined - these locations are marked magenta.
To understand which variable is used in each location, you need to apply the scoping rule (since the variable j is a local variable, you need to apply the scoping rules for local variables - which we have just studied...)
By applying the scoping rule, we can determine that:
- The variable j in line (1) refers the the variable int j defined in line (A)
- The variable j in line (2) refers the the variable String j defined in line (B)
- The variable j in line (3) CANNOT be associated with any variable with that name !!!
  This is an ERROR !!!

Example Program: (Demo above code)

Prog file: click here

When you compile this program you will see the error:

	Scoping1.java:20: cannot find symbol
	symbol  : variable j
	location: class Scoping1
      		System.out.println(j);      <<--- occured in line 20

Scope of a parameter variable
- A parameter variable behaves exactly like a local variable that is defined at the start of the method (except for the fact that the parameter variable is initialized by the caller of the method instead of inside the method) - see click here
- Hence, it should not be surpsing that the scope of a parameter variable is the whole method body (the method body is in fact a block !)
  In other words: the parameter variables of a method is accessible anywhere within the body of the method...
- (This would also be the case when we define local variables at the very beginning of a method - and that's why I define every local variable at the start of the method so I don't have to explain scoping until now...)