Incremental Java
Local Variables and Scope

Local Variables, Scope, and Lifetime

In a class definition, there are three kinds of variables.

instance variables Any method in the class definition can access these variables
parameter variables Only the method where the parameter appears can access these variables. This is how information is passed to the object.
local variables Only the method where the parameter appears can access these variables. These variables are used to store intermediate results.

Let's look at an example:

public class TwoSides
{
   int side1, side2 ;
   public boolean testRightTriangle( int hypoteneuse )
   {
      int side1Squared = side1 * side1 ;
      int side2Squared = side2 * side2 ;
      int hypSquared = hypoteneuse * hypoteneuse ;

      return side1Squared + side2Squared == hypSquared ;
   }
}

In this example, which checks if we have a right triangle (the class contains the two short sides of a triangle, and we pass the long side, i.e., the hypoteneuse). We apply Pythagorean's theorem to check if it's a right triangle.

In this example:

side1, side2 are instance variables. Any method in TwoSides can access these variables directly.
We say the scope of instance variables is the entire class definition. The scope refers to the section of code where a variable can be accessed.
hypoteneuse is a parameter variable for testRightTriangle and can only be accessed in the method body, testRightTriangle.
The scope for a parameter is simply the method body in which the parameter is located.
Parameter names only have to be unique in a parameter list. For example, we can have two methods testRightTriangle and testScaleneTriangle, both of which have parameter int hypoteneuse. Since the scope is just the method body, we know which hypoteneuse is being referred to.
For example:
```
public class TwoSides
{
   int side1, side2 ;
   public boolean testRightTriangle( int hypoteneuse )
   {
      // hypoteneuse refers to parameter above
      // hypoteneuse is NOT same as testScaleneTriangle
   }
   public boolean testScaleneTriangle( int hypoteneuse )
   {
      // hypoteneuse refers to parameter above
      // hypoteneuse is NOT same as testRightTriangle
   }
}
```
Each method has its own hypoteneuse and they do not affect each other.
side1Squared, side2Squared, and hypSquared are local variables in testRightTriangle. They are only valid in testRightTriangle.
The scope begins at the point of declaration, and lasts to the end of the method body (this isn't exactly true, but it's true in the example above). You must declare a variable before use.
Again, more than one method can define the same name for a local variable. For example, we could have both testRightTriangle() and testScaleneTriangle can both have a local variable temp. These are not related variables. Each has its own box, and you should think of them as completely different, even though they share the same name.

Local Variables Have No Memory

When you exit a method, both the local variables and the parameter variables disappear (although, if you pass an object as a parameter, you usually have access to the object when you exit the method).

That means if you make a call to testRightTriangle() and run the declarations, it creates new boxes and initializes them. When you exit, those local variables disappears.

When you call it a second time, it recreates the local variables, and reinitializes them.

Parameters behave somewhat like this. These variables gets initalized to the arguments.

Only instance variables maintain their value over method calls. That is, if some instance variable has value of 4 for height, and you change it to 10, then the next time you make a method call, it's still 10. It stays 10 until some method call changes the value.

Lifetime

Different kinds of variables have different lifetimes. Parameter variables exist when the method call is made, and lasts until the method call is complete. These parameter variables hold boxes to values or handles. If the box holds handles (i.e., the parameter variable is an object variable), then when the box disappears, the handle may still stay around. That's usually because you have some variable around that holds the handle, and was passed to the method as an argument.

Local variables also have a similar lifetime. The boxes are created when the declaration appears, and lasts until you exit the method.

Instance variables have a much longer lifetime. They are created when the object is constructed, and goes away when the object disappears. The object disappears when it is no longer being used, which basically means that no variable has a handle to the object. When that happens, the garbage collector gets rid of the object.

The garbage collector is a program that runs when your program runs, and looks for objects (balloons) with no variables that have handles to it.

Scope vs. Lifetime

Scope refers to the range of code where you can access a variable. You can literally print out your program, and draw a box to show where a variable is valid. It's textual in nature. We can divide scope into

method body scope Variable is accessible in method body only (local variables, parameters)
class definition scope Variable is accessible i class definition (instance variables)

Lifetime refers to the amount of time a variable (or object) exists. Since object variables are both a box (holding a handle) and an object, the lifetimes may differ. An object variable could disappear (for example, a local variable disappears once you exit the method where the local variable is declared), yet the object still exists.

We can divide lifetime into categories too:

method body lifetime Exists on method body entry, disappears on method body exit. (local variables, parameters)
class definition lifetime Exists as long as object is around (instance variables)

Incremental Java Local Variables and Scope

Local Variables, Scope, and Lifetime

Local Variables Have No Memory

Lifetime

Scope vs. Lifetime

Incremental Java
Local Variables and Scope