Skip to main content

Computational Problem Solving with Java and Interactive Object Graphics

Mark F. Russo, PhD

Section 5.7 Block Scope

Recall that the scope of a variable is defined by where it is declared and it dictates from where it may be accessed. In Section 4.4 we introduced the main Java program scope list. These were as follows, listed in order from least restrictive to most restrictive.
  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),
Before closing this chapter, it is a good time to introduce block scope, the most restrictive scope in Java.
Variables may be declared in many Java program locations, including within a statement such as an if-statement or while-statement. The block of code associated with one of these statements forms its own scope, appropriately called block scope.
As with other Java scopes, if a variable is declared within a code block it may not be accessed outside that block. The compiler can detect this mistake and will let us know when you try to violate this rule. Consider the following small example and the attempt to compile this program in the shell session that follows. The compiler tells us that it cannot access the variable o because it was declared within the scope of the while-statement, which has block scope, and so it cannot be accessed outside that scope. This is true even though we access the variable within the method scope to initialize the fill color of all Oval objects to green.
// BlockScope.java
import doodlepad.*;

public class BlockScope {
  public static void main(String[] args) {
    int i = 0;                          // Init counter
    while (i < 10 ) {                   // Loop 10 times
      Oval o = new Oval();              // Create 10 Ovals
      o.setFillColor(0, 255, 0);        // Set fill to green
      i++;                              // Increment counter
    }
    o.setFillColor(255, 0, 0);          // Set fill of last Oval to red
  }
}
Listing 5.7.1. 
javac -cp doodlepad.jar BlockScope.java
BlockScope.java:12: error: cannot find symbol
        o.setFillColor(255, 0, 0);
        ^
    symbol:   variable o
    location: class BlockScope
1 error
In general, it is a very good idea to declare your variables in a scope that is as narrow as feasible and still be able to solve your problem. You may be tempted to just declare all variables in the outer class scope so that you don’t have to worry about declaring them again. Resist the temptation. This is often the cause for subtle bugs that can be very hard to find.
In the Listing 5.7.2, we declare i once at the top of our program so we never have to worry about it again. In the main(…) method, we loop 5 times and each time invoke the helper method repeatChars(…), which takes char and count parameters identifying the character to repeat and the number of times to repeat it in the returned String. The main(…) prints the constructed String and continues to the next iteration.
public class CharRepeats {
  // Declare once for entire program
  public static int i = 0;

  public static void main(String[] args) {
    // Print strings with progressively longer char lengths
    i = 0;                                      // Init counter
    while (i < 5) {                             // Repeat 5 times
      String repeated = repeatChars('A', i+1);  // Build String
      System.out.println(repeated);             // Print String
      i++;                                      // Increment counter
    }
  }

  // Method to build a repeated-character String
  public static String repeatChars(char ch, int count) {
    StringBuilder sb = new StringBuilder();     // StringBuilder
    i = 0;                                      // Init counter
    while (i < count) {                         // Loop for all chars
      sb.append(ch);                            // Append ch
      i++;                                      // Increment counter
    }
    return sb.toString();                       // Return String
  }
}
Listing 5.7.2. CharRepeats.java
Next we compile and run the program. The program compiles and runs just fine, and it looks correct. In fact, when testing the repeatChars(…) method individually, outside the iteration in the main(…) method, it worked correctly. The loop counter i is properly initialized and incremented by 1 every time. I expected the output "A", "AA", "AAA", "AAAA", "AAAAA". But as you can see below the output is "A", "AAA", "AAAAA". It is clear that the counter in main(…) increases by 1 each time. I can see with my own eyes the statement i++;. So what is the problem? Could it have something to do with the variable i that we declared in the outer class scope?
javac CharRepeats.java
java CharRepeats
A
AAA
AAAAA
If you look closely you will see that i is used as the counter for the iteration in the main(…) method as well as in the repeatChars(…) method. In both cases i is reset to 0, but repeatChars(…) leaves the value of i at count + 1. When repeatChars(…) exits it returns to the while-statement in main(…) already in progress. This statement continues, but does so with a value of i that has been changed by repeatChars(…). In this case, the result is that the counter is advanced too quickly, resulting in some of the expected output being skipped.

Principle: Most Narrow Scope Feasible.

Always declare your variables in the most narrow scope feasible, while still allowing your program to solve your problem. This practice minimizes the chances that a single variable declared in an outer scope but used in multiple inner scopes for different purposes are inadvertently modified unexpectedly. This avoid bugs that are hard to fine.
<Prev^TopNext>