Scope and Access

How the examples in this chapter are laid out. Each example is one runnable file that holds two classes: a class with main that tries things out, and the class being studied. Java allows only one public class per file, so the second class is written as plain class Trip instead of public class Trip. In the course, and on the exam, every class is public and lives in its own file. Leaving public off here changes nothing this chapter teaches; in particular, private still keeps the other class out, as you will see in 3.8.4.

Picture a class with ten methods. Each method needs a few working variables: a total here, a counter there, a temporary result. If every one of those variables could be seen by every method, you would have to invent a different name for each, and a typo in one method could quietly change a value another method depends on. Java avoids this by limiting where each variable can be used.

You have already met this limit. In Topic 2.8 you read that a variable declared in a for loop header “belongs to that loop” and cannot be used after it, and in Topic 2.10 that a counter declared inside a loop body “exists only inside those braces.” This subsection gives that rule its real name and shows that it is not special to loops.

The part of a program where a variable’s name can be used is called the variable’s scope. Outside its scope, the name means nothing to Java, just as a locker number means nothing in a different school.

Scope is measured in blocks. A block is a section of code between a matching { and }. The body of a method is a block, the body of a constructor is a block, and so are the bodies of loops and if statements. A local variable is a variable declared inside a block (or in the header that opens a block, such as a for loop header). Its scope starts at its declaration and ends at the closing brace of the block it was declared in.

public class TripReport
{
    public static void main(String[] args)
    {
        Trip drive = new Trip(150, 3);
        drive.printSpeed();
        drive.printFuel();
    }
}

class Trip
{
    private int miles;
    private int hours;

    public Trip(int distance, int time)
    {
        miles = distance;
        hours = time;
    }

    public void printSpeed()
    {
        int speed = miles / hours;
        System.out.println("Average speed: " + speed + " mph");
    }

    public void printFuel()
    {
        double gallons = miles / 30.0;
        System.out.println("Fuel used: " + gallons + " gallons");
    }
}

Average speed: 50 mph
Fuel used: 5.0 gallons

What happens if a method reaches for another method’s local variable? Change one thing: replace printFuel with a printSummary method that wants to reuse speed.

public class TripSummaryError
{
    public static void main(String[] args)
    {
        Trip drive = new Trip(150, 3);
        drive.printSpeed();
        drive.printSummary();
    }
}

class Trip
{
    private int miles;
    private int hours;

    public Trip(int distance, int time)
    {
        miles = distance;
        hours = time;
    }

    public void printSpeed()
    {
        int speed = miles / hours;
        System.out.println("Average speed: " + speed + " mph");
    }

    public void printSummary()
    {
        System.out.println(miles + " miles at " + speed + " mph");
    }
}

TripSummaryError.java:30: error: cannot find symbol
        System.out.println(miles + " miles at " + speed + " mph");
                                                  ^
  symbol:   variable speed
  location: class Trip

Because each method’s local variables belong only to that method’s block, two methods may use the same local variable name without any conflict. They are two different variables that happen to share a name.

public class TwoTotals
{
    public static void main(String[] args)
    {
        Cart cart = new Cart(4, 2.5);
        System.out.println(cart.itemCost());
        System.out.println(cart.costWithShipping());
        System.out.println(cart.itemCost());
    }
}

class Cart
{
    private int items;
    private double price;

    public Cart(int count, double each)
    {
        items = count;
        price = each;
    }

    public double itemCost()
    {
        double total = items * price;
        return total;
    }

    public double costWithShipping()
    {
        double total = items * price;
        total = total + 5.0;
        return total;
    }
}

10.0
15.0
10.0

The last bullet shows something about time as well as place. A local variable is created when its declaration runs and disappears when its block ends. When the method is called again, the declaration runs again and makes a fresh variable. A local variable cannot remember anything from one call to the next. Instance variables can, because they belong to the object and last as long as the object does.

public class VisitCounterBug
{
    public static void main(String[] args)
    {
        Page home = new Page();
        System.out.println(home.visit());
        System.out.println(home.visit());
        System.out.println(home.visit());
    }
}

class Page
{
    public int visit()
    {
        int visits = 0;
        visits++;
        return visits;
    }
}

1
1
1

public class VisitCounterFixed
{
    public static void main(String[] args)
    {
        Page home = new Page();
        System.out.println(home.visit());
        System.out.println(home.visit());
        System.out.println(home.visit());
    }
}

class Page
{
    private int visits;

    public Page()
    {
        visits = 0;
    }

    public int visit()
    {
        visits++;
        return visits;
    }
}

1
2
3

public class TimerQuestion
{
    public static void main(String[] args)
    {
        Timer oven = new Timer(150);
        oven.printMinutes();
        oven.printLeftover();
    }
}

class Timer
{
    private int seconds;

    public Timer(int s)
    {
        seconds = s;
    }

    public void printMinutes()
    {
        int minutes = seconds / 60;
        System.out.println(minutes);
    }

    public void printLeftover()
    {
        int leftover = seconds - minutes * 60;
        System.out.println(leftover);
    }
}

public class ClickerTrace
{
    public static void main(String[] args)
    {
        Clicker counter = new Clicker();
        System.out.println(counter.click());
        System.out.println(counter.click());
        System.out.println(counter.click());
    }
}

class Clicker
{
    private int total;

    public Clicker()
    {
        total = 0;
    }

    public int click()
    {
        int presses = 0;
        presses++;
        total++;
        return presses + total;
    }
}

2
3
4

A method body is the biggest block inside a method, but it is rarely the only one. As soon as a method contains a loop or an if statement, it has blocks inside blocks, and the scope rule from 3.8.1 applies to every one of them.

Think of nested blocks as rooms inside a house with one-way windows. Code in an inner room can see everything declared in the rooms around it, so a loop body can use the method’s variables. Code in an outer room cannot see into an inner one, so the method cannot use a variable declared inside the loop body. (Unlike real windows, the view stops at the method’s walls: one method still cannot see another method’s variables.)

A variable declared in a for loop header is a special case worth naming: its scope is the header plus the loop body, and it ends when the loop does.

public class CountLetter
{
    public static void main(String[] args)
    {
        Word fruit = new Word("banana");
        System.out.println(fruit.countLetter("a"));
    }
}

class Word
{
    private String text;

    public Word(String t)
    {
        text = t;
    }

    public int countLetter(String letter)
    {
        int count = 0;
        for (int i = 0; i < text.length(); i++)
        {
            String current = text.substring(i, i + 1);
            if (current.equals(letter))
            {
                count++;
            }
        }
        return count;
    }
}

Now suppose you want the position of the last match instead of a count. The tempting code records the position at the moment it finds a match:

public class FindLastError
{
    public static void main(String[] args)
    {
        Word fruit = new Word("banana");
        System.out.println(fruit.findLast("a"));
    }
}

class Word
{
    private String text;

    public Word(String t)
    {
        text = t;
    }

    public int findLast(String letter)
    {
        for (int i = 0; i < text.length(); i++)
        {
            String current = text.substring(i, i + 1);
            if (current.equals(letter))
            {
                int position = i;
            }
        }
        return position;
    }
}

FindLastError.java:29: error: cannot find symbol
        return position;
               ^
  symbol:   variable position
  location: class Word

public class FindLastFixed
{
    public static void main(String[] args)
    {
        Word fruit = new Word("banana");
        System.out.println(fruit.findLast("a"));
        System.out.println(fruit.findLast("z"));
    }
}

class Word
{
    private String text;

    public Word(String t)
    {
        text = t;
    }

    public int findLast(String letter)
    {
        int position = -1;
        for (int i = 0; i < text.length(); i++)
        {
            String current = text.substring(i, i + 1);
            if (current.equals(letter))
            {
                position = i;
            }
        }
        return position;
    }
}

5
-1

Since a variable disappears when its block ends, its name is free again afterward. Two loops one after the other may each declare their own i:

for (int i = 1; i <= 3; i++)
{
    System.out.println(i);
}
for (int i = 10; i <= 30; i += 10)
{
    System.out.println(i);
}

1
2
3
10
20
30

The first i goes out of scope at the end of the first loop (line 4), so line 5 may declare a new i. The two never exist at the same time.

The rule is different for blocks inside one another. While a variable is in scope, an inner block may not declare another variable with the same name. Java refuses because a name in the inner block would be ambiguous: which one did you mean?

int i = 0;
for (int i = 1; i <= 3; i++)
{
    System.out.println(i);
}

error: variable i is already defined in method main(String[])

int total = 0;
for (int day = 1; day <= 3; day++)
{
    int total = total + day * 10;
    System.out.println(total);
}

    total = total + day * 10;

When a constructor runs, its parameters hold the values the caller supplied. Can a method called later still use them? Answering that question correctly is the difference between a class that works and one full of cannot find symbol errors.

Recall from Topic 3.5 that a parameter is declared in a method’s (or constructor’s) header, and that each call starts the parameter off as a copy of the argument. The header is the line that opens the body’s block, just as a for loop header opens the loop’s block. So Java treats parameters exactly like local variables declared at the very top of the body: a parameter is a local variable whose scope is its constructor’s or method’s body, and nothing else.

public class ThermostatDemo
{
    public static void main(String[] args)
    {
        Thermostat home = new Thermostat(68);
        home.raise(4);
        home.raise(2);
        System.out.println("Target: " + home.getTarget());
    }
}

class Thermostat
{
    private int target;

    public Thermostat(int startTemp)
    {
        target = startTemp;
    }

    public void raise(int degrees)
    {
        target = target + degrees;
    }

    public int getTarget()
    {
        return target;
    }
}

Target: 74

Change one thing: add a reset method that should put the thermostat back to the temperature it started at.

public class ThermostatResetError
{
    public static void main(String[] args)
    {
        Thermostat home = new Thermostat(68);
        home.raise(4);
        home.reset();
        System.out.println("Target: " + home.getTarget());
    }
}

class Thermostat
{
    private int target;

    public Thermostat(int startTemp)
    {
        target = startTemp;
    }

    public void raise(int degrees)
    {
        target = target + degrees;
    }

    public void reset()
    {
        target = startTemp;
    }

    public int getTarget()
    {
        return target;
    }
}

ThermostatResetError.java:28: error: cannot find symbol
        target = startTemp;
                 ^
  symbol:   variable startTemp
  location: class Thermostat

public class ThermostatResetFixed
{
    public static void main(String[] args)
    {
        Thermostat home = new Thermostat(68);
        home.raise(4);
        System.out.println("Target: " + home.getTarget());
        home.reset();
        System.out.println("Target: " + home.getTarget());
    }
}

class Thermostat
{
    private int target;
    private int startingTarget;

    public Thermostat(int startTemp)
    {
        target = startTemp;
        startingTarget = startTemp;
    }

    public void raise(int degrees)
    {
        target = target + degrees;
    }

    public void reset()
    {
        target = startingTarget;
    }

    public int getTarget()
    {
        return target;
    }
}

Target: 72
Target: 68

Because a parameter and a local variable declared at the top of the body share the same block, the “already defined” rule from 3.8.2 applies between them too.

public class ParamRedeclare
{
    public static void main(String[] args)
    {
        Thermostat home = new Thermostat(68);
        home.raise(4);
        System.out.println("Target: " + home.getTarget());
    }
}

class Thermostat
{
    private int target;

    public Thermostat(int startTemp)
    {
        target = startTemp;
    }

    public void raise(int degrees)
    {
        int degrees = 5;
        target = target + degrees;
    }

    public int getTarget()
    {
        return target;
    }
}

ParamRedeclare.java:22: error: variable degrees is already defined in method raise(int)

public class PlayerNameError
{
    public static void main(String[] args)
    {
        Player hero = new Player("Ada", 3);
        hero.greet();
    }
}

class Player
{
    private String name;
    private int level;

    public Player(String playerName, int startLevel)
    {
        name = playerName;
        level = startLevel;
    }

    public void greet()
    {
        System.out.println("Welcome, " + playerName + "! Level " + level);
    }
}

        System.out.println("Welcome, " + name + "! Level " + level);

    public void lower(int degrees)
    {
        target = target - degrees;
    }

So far, local variables have had small scopes, and instance variables have been usable “in every method.” It is time to say exactly why, and to connect scope with the access keywords from Topic 3.3.

An instance variable is declared in the class body, outside every constructor and method. The class body is the outermost block of the class, and every constructor and method sits inside it. So by the same inner-sees-outer rule from 3.8.2, every constructor and method can use every instance variable. The same holds for the class’s methods: any method of the class can call any other method of the class.

Scope answers “where in this class can the name be used?” A second question remains: can code in a different class use it, through an object? That is what the access keywords control. Recall from Topic 3.3 that the keywords public and private (called access modifiers) are written in front of instance variables, constructors, and methods. private limits use to code written inside the declaring class. public also allows use from other classes.

public class BankDemo
{
    public static void main(String[] args)
    {
        Account checking = new Account(50.0);
        checking.deposit(25.5);
        checking.deposit(-10.0);
        System.out.println(checking.getBalance());
    }
}

class Account
{
    private double balance;

    public Account(double opening)
    {
        balance = opening;
    }

    public void deposit(double amount)
    {
        if (isPositive(amount))
        {
            balance = balance + amount;
        }
    }

    public double getBalance()
    {
        return balance;
    }

    private boolean isPositive(double amount)
    {
        return amount > 0;
    }
}

75.5

What if main skips the methods and reads the variable itself?

public class BankPrivateError
{
    public static void main(String[] args)
    {
        Account checking = new Account(50.0);
        checking.deposit(25.5);
        System.out.println(checking.balance);
    }
}

class Account
{
    private double balance;

    public Account(double opening)
    {
        balance = opening;
    }

    public void deposit(double amount)
    {
        if (isPositive(amount))
        {
            balance = balance + amount;
        }
    }

    public double getBalance()
    {
        return balance;
    }

    private boolean isPositive(double amount)
    {
        return amount > 0;
    }
}

BankPrivateError.java:7: error: balance has private access in Account
        System.out.println(checking.balance);
                                   ^

public class BankPrivateMethodError
{
    public static void main(String[] args)
    {
        Account checking = new Account(50.0);
        if (checking.isPositive(20.0))
        {
            checking.deposit(20.0);
        }
        System.out.println(checking.getBalance());
    }
}

class Account
{
    private double balance;

    public Account(double opening)
    {
        balance = opening;
    }

    public void deposit(double amount)
    {
        if (isPositive(amount))
        {
            balance = balance + amount;
        }
    }

    public double getBalance()
    {
        return balance;
    }

    private boolean isPositive(double amount)
    {
        return amount > 0;
    }
}

BankPrivateMethodError.java:6: error: isPositive(double) has private access in Account

Two different checks can stop a name, so keep them apart:

public class TicketQuestion
{
    public static void main(String[] args)
    {
        Ticket show = new Ticket(12.0);
        System.out.println( /* expression goes here */ );
    }
}

class Ticket
{
    private double price;

    public Ticket(double cost)
    {
        price = cost;
    }

    public double getPrice()
    {
        return price;
    }

    private double discount()
    {
        return price * 0.5;
    }
}

If private protects instance variables so well, why not mark a method’s local variables private too, just to be safe? Java will not let you, and the reason follows directly from scope.

An access modifier answers one question: which classes may use this member through an object? That question only makes sense for things that belong to the class or object and last beyond one method call: instance variables, constructors, and methods (and the class variables from Topic 3.7). A local variable is already far more restricted than private. It cannot be used outside its own block, not even by another method of the same class, and it disappears when the block ends. No other class could ever reach it, so there is nothing for public or private to decide. Because the keyword would be meaningless, Java treats it as a mistake.

public class PrivateLocal
{
    public static void main(String[] args)
    {
        Quiz test = new Quiz(18);
        System.out.println(test.finalScore());
    }
}

class Quiz
{
    private int points;

    public Quiz(int earned)
    {
        points = earned;
    }

    public int finalScore()
    {
        private int bonus = 2;
        return points + bonus;
    }
}

PrivateLocal.java:21: error: illegal start of expression
        private int bonus = 2;
        ^

Parameters are local variables too, so the same rule applies to them. Here only the parameter changed:

public class PrivateParam
{
    public static void main(String[] args)
    {
        Quiz test = new Quiz(18);
        test.addPoints(3);
        System.out.println(test.getPoints());
    }
}

class Quiz
{
    private int points;

    public Quiz(int earned)
    {
        points = earned;
    }

    public void addPoints(private int extra)
    {
        points = points + extra;
    }

    public int getPoints()
    {
        return points;
    }
}

PrivateParam.java:20: error: modifier private not allowed here
    public void addPoints(private int extra)
                                  ^

Naming a constructor parameter after the instance variable it fills in seems like the clearest choice: the parameter for coins should be called coins, right? It compiles, too. But the program can then quietly do the wrong thing.

From 3.8.2, Java does not allow a local variable to reuse the name of another local variable that is still in scope. Instance variables are different: they are not local, so a local variable or parameter may have the same name as an instance variable. When that happens, there are two variables with one name in scope at the same time, and Java needs a rule to decide which one the name means.

The rule: inside that constructor or method, wherever the local variable or parameter is in scope, the name refers to the local variable (or parameter), not the instance variable. The closer declaration wins. Programmers say the local variable shadows the instance variable: it stands in front of it and hides it, the way a person standing close to you can block your view of someone farther away.

public class CoinJarBug
{
    public static void main(String[] args)
    {
        CoinJar jar = new CoinJar(40);
        System.out.println("Coins: " + jar.getCoins());
    }
}

class CoinJar
{
    private int coins;

    public CoinJar(int coins)
    {
        coins = coins;
    }

    public int getCoins()
    {
        return coins;
    }
}

Coins: 0

    public CoinJar(int startCoins)
    {
        coins = startCoins;
    }

Shadowing does not need a parameter. Change one thing: here the name clash comes from a local variable declared in a constructor.

public class ScoreboardBug
{
    public static void main(String[] args)
    {
        Scoreboard game = new Scoreboard();
        System.out.println("Lives: " + game.getLives());
        game.loseLife();
        System.out.println("Lives: " + game.getLives());
    }
}

class Scoreboard
{
    private int lives;
    private int score;

    public Scoreboard()
    {
        int lives = 3;
        score = 0;
    }

    public void loseLife()
    {
        lives--;
    }

    public int getLives()
    {
        return lives;
    }
}

Lives: 0
Lives: -1

        lives = 3;

public class TankTrace
{
    public static void main(String[] args)
    {
        Tank truck = new Tank(50);
        System.out.println(truck.afterTrip(30));
        System.out.println(truck.getFuel());
    }
}

class Tank
{
    private int fuel;

    public Tank(int startFuel)
    {
        fuel = startFuel;
    }

    public int afterTrip(int fuel)
    {
        fuel = fuel - 10;
        return fuel;
    }

    public int getFuel()
    {
        return fuel;
    }
}

20
50

public class PetAgeBug
{
    public static void main(String[] args)
    {
        Pet dog = new Pet(2);
        dog.setAge(5);
        System.out.println("Age: " + dog.getAge());
    }
}

class Pet
{
    private int age;

    public Pet(int startAge)
    {
        age = startAge;
    }

    public void setAge(int age)
    {
        age = age;
    }

    public int getAge()
    {
        return age;
    }
}

    public void setAge(int newAge)
    {
        age = newAge;
    }

This program tracks a summer reading goal. It uses every kind of variable from this chapter. Before reading the trace, try to list each variable’s scope yourself.

public class ReadingLog
{
    public static void main(String[] args)
    {
        BookLog summer = new BookLog(20);
        summer.logDay(25);
        summer.logDay(12);
        summer.logDay(20);
        System.out.println(summer.summary());
    }
}

class BookLog
{
    private int goal;
    private int days;
    private int totalPages;
    private int goalDays;

    public BookLog(int pagesPerDay)
    {
        goal = pagesPerDay;
        days = 0;
        totalPages = 0;
        goalDays = 0;
    }

    public void logDay(int pages)
    {
        days++;
        totalPages += pages;
        if (pages >= goal)
        {
            goalDays++;
        }
    }

    public String summary()
    {
        String stars = "";
        for (int i = 0; i < goalDays; i++)
        {
            stars += "*";
        }
        double average = (double) totalPages / days;
        return days + " days, " + average + " pages per day " + stars;
    }
}

3 days, 19.0 pages per day **

Step 1: map the scopes.

No local name matches an instance variable, so nothing is shadowed: every use of goal, days, totalPages, and goalDays inside BookLog reaches the instance variables. Line 22 is what lets logDay compare against the goal later, since pagesPerDay disappears when the constructor ends.

Step 2: trace the calls.

Each call to logDay gets a fresh pages, but the instance variables carry their values from call to call. On the third call, 20 >= 20 is true, so the goal counts.

Step 3: the summary. Line 9 calls summary. Line 40 creates stars as "". The loop runs goalDays times (twice), so stars becomes "**"; i goes out of scope at line 44. Line 45 creates average as 57.0 / 3, which is 19.0. Line 46 builds and returns the text, and line 9 prints it. When summary returns, stars and average are gone, while the instance variables remain in the object for any later call.

What one small change would break. If line 22 were written int goal = pagesPerDay;, the constructor would declare a local goal that shadows the instance variable (3.8.6). The instance goal would stay 0, every day would meet the goal, and the output would end with ***. And if main tried to print summer.days, Java would report days has private access in BookLog (3.8.4).

Most mistakes in this chapter show up as compiler messages. Use this table to go from the message to the cause.

• A variable’s scope is where its name can be used. A local variable’s scope runs from its declaration to the closing brace of the block it was declared in, and Java checks this at compile time (cannot find symbol).
• Blocks nest: inner blocks can use variables from the blocks around them, but not the other way around. A name can be reused in separate blocks, but not declared again while it is still in scope (already defined).
• Parameters are local variables of their constructor or method. To keep a parameter’s value for other methods, copy it into an instance variable. Local variables are created fresh on each call, so they cannot remember values between calls.
• Instance variables and methods can be used anywhere in their class; private stops other classes from using them (has private access). Local variables and parameters can never be public or private.
• When a local variable or parameter has the same name as an instance variable, the name means the local one there. This compiles, so the symptom is an instance variable that never changes from its default.

public class PlaylistChoice
{
    public static void main(String[] args)
    {
        Playlist mix = new Playlist();
        mix.addSong(200);
        System.out.println(mix.lengthText());
    }
}

class Playlist
{
    private int songs;
    private int totalSeconds;

    public Playlist()
    {
        songs = 0;
        totalSeconds = 0;
    }

    public void addSong(int seconds)
    {
        songs++;
        totalSeconds += seconds;
    }

    public String lengthText()
    {
        int minutes = totalSeconds / 60;
        return songs + " songs, " + minutes + " min, last song " + seconds + " s";
    }
}

public class GardenTrace
{
    public static void main(String[] args)
    {
        Garden yard = new Garden(10);
        yard.plantRows(3);
        System.out.println("Total: " + yard.getPlants());
    }
}

class Garden
{
    private int plants;

    public Garden(int start)
    {
        plants = start;
    }

    public void plantRows(int rows)
    {
        int plants = 0;
        for (int r = 1; r <= rows; r++)
        {
            plants += 4;
        }
        System.out.println("Planted: " + plants);
    }

    public int getPlants()
    {
        return plants;
    }
}

Planted: 12
Total: 10

public class RaceBestBug
{
    public static void main(String[] args)
    {
        Runner sam = new Runner();
        sam.record(12.5);
        sam.record(11.8);
        sam.record(12.1);
        System.out.println("Best: " + sam.getBest());
    }
}

class Runner
{
    private double bestTime;

    public Runner()
    {
        double bestTime = 99.0;
    }

    public void record(double time)
    {
        if (time < bestTime)
        {
            bestTime = time;
        }
    }

    public double getBest()
    {
        return bestTime;
    }
}

        bestTime = 99.0;

int score = 85;
if (score >= 80)
{
    String message = "Great job";
    System.out.println(message);
}
if (score < 90)
{
    String message = "Keep going";
    System.out.println(message);
}

int total = 0;
for (int i = 1; i <= 3; i++)
{
    int doubled = i * 2;
    total += doubled;
}
System.out.println(total);

String word = "hop";
for (int k = 0; k < word.length(); k++)
{
    String word = word.substring(k, k + 1);
    System.out.println(word);
}

public class SameNameTrace
{
    public static void main(String[] args)
    {
        int pages = 10;
        Book novel = new Book(300);
        novel.read(pages);
        System.out.println(pages);
        System.out.println(novel.getPagesLeft());
    }
}

class Book
{
    private int pagesLeft;

    public Book(int total)
    {
        pagesLeft = total;
    }

    public void read(int pages)
    {
        pagesLeft = pagesLeft - pages;
        pages = 0;
    }

    public int getPagesLeft()
    {
        return pagesLeft;
    }
}

10
290

• I can explain what scope is and find the lines where a local variable can be used. Reread
• I can explain why a local variable cannot remember its value from one method call to the next. Reread
• I can tell which variables are in scope inside nested loop and if blocks, and when a name may be reused. Reread
• I can explain why a parameter cannot be used in another method, and how to keep its value. Reread
• I can tell the difference between cannot find symbol and has private access. Reread
• I can explain why local variables and parameters are never public or private. Reread
• I can predict which variable a shadowed name refers to and fix the bug it causes. Reread