1. Local Variables and Scope Benjamin Fein

2. Variable Scope A variable’s scope consists of all code blocks in which it is visible. A variable is considered visible if it can be accessed by statements within that code block. Java Code block: One or more lines of code contained between braces {} Code blocks can be nested –{ Statement1; {Statement2;}}

3. Variable Scope cont. What is a variable’s scope? –Starts at the declaration statement –Ends at the end of the block it was declared in Field: Variables declared in a class declaration block, outside of methods or constructors A field’s scope is the whole class. The field must be declared before any initialization block, but can be after method declaration.

4. Variable Scope Example Below, block 1 declares A. Block 2 declares B. A’s scope is within all the blocks. B’s scope is only in block 2. Block 3 cannot access B because it is located outside of block 2’s enclosing braces, so it will generate an error! –Block 1 : {Var A; A = 10; Block 2 : {Var B; B = 2 *A;} <- inside 1 Block 3 : {B = A;} } <-end of block 1 Error ^

5. Classes and Variable Scope The class code below acts the same as the code blocks example in the previous slide. –class A { Var A1 = 10;//A1 is a field } class B extends A { // Var A1 ’ s scope includes B Var B1 = 2 * A1; } class C extends A { // A1 ’ s scope includes C B1 = 2 * A1;}// illegal, B1 not // in scope

6. Local Variables A code block’s local variables are those declared in the code block. –NOT variables from higher code blocks: A in above example is local variable for block 1 only –NOT variables declared in nested sub-blocks: B in above example is NOT local to block 1. A class’s fields are not considered local variables: they are member variables

7. Local Variables A method’s parameters are local to the block of the method’s body. –public void aMethod(int A){...}; If new variables are declared in the initialization of a for loop, they are local to the loop body. –for (int i = 0; i < N; i++); i’s scope is just the body of the loop.

8. Hiding fields If a local variable is declared with the same name as an in scope field, that field is “hidden” or “shadowed”. –class MyClass { int A; // field public void someMethod() { String A;// Local variable }

9. Hiding Fields If a sub-class declares a field with the same name as one of the inherited fields of its parent, the parent’s field is hidden –class MyClass { int A; } class SubClass extends MyClass { int A; }

10. Hiding Fields cont. In the above example, in someMethod, A1 is a local variable of type String. The field A1 is only accessible with the this reference within someMethod: –A1 = “ Blah ” ;// local A1, String –this.A1 = 5;// field A1, int If one of a method’s parameters have same name as a field, also hides the field

11. Avoid Hiding Fields Hiding should generally be avoided, with the following exceptions –In constructors, the parameters holding values to set fields to can have the same name as the field –Within a class’s methods, it is ok to hide/shadow instance fields of that class if the local variable is a copy of the field, since readability will be improved.

12. Hiding Variables? Variables, unlike fields, cannot be hidden –public void someMethod(int B) { int A; { int A; // illegal statement int B; // illegal statement } }

13. Common Mistakes Declaring a variable in a for loop then trying to use it after the loop –for (int i = 0; i < size; i++) {... //do loop stuff } System.out.println( “ Count: “ + i); The above is incorrect, since the scope of i ends at the end of the for loop. To correct: declare i before the loop

14. Corrected Mistake Correction of above example: –int i; for (i = 0; i < size; i++) {... //do loop stuff } System.out.println( “ Count: “ + i);

15. Conclusion A variable’s scope starts at declaration, extends to nested blocks, and ends at the end of the block it was declared in. A blocks local variables are variables declared within that block of code, but do not include variables declared in nested blocks. A class’s fields can be hidden by local variables or method parameters, but this is generally a bad idea unless the variable is a copy.

16. Bibliography Jia, Xiaoping. Object-Oriented Software Development Using Java. 2 nd ed. New York: Pearson/Addison Wesley, 2003. p 116- 117. Scope. Sun Microsystems. http://java.sun.com/docs/books/tutorial/java/nutsandbolts/scope. html http://java.sun.com/docs/books/tutorial/java/nutsandbolts/scope. html Sebesta, Robert W. Concepts of Programming Languages. 7 th ed. New York: Pearson/Addison Wesly, 2006. p 228-234.