3.8 Scope and Access

1. Local variables live inside their block

Local variables are variables declared in the header or body of a block of code. A block is code between { and }, such as a method body, a loop or an if. A local variable can only be accessed in the block where it is declared 3.8.A.1.

public class Rainfall
{
    public static int total(int days)
    {
        int sum = 0;
        for (int day = 1; day <= days; day++)
        {
            int rain = day * 2;
            sum += rain;
        }
        return sum;
    }
}

System.out.println(Rainfall.total(3));

Output:

12

Variable	Declared in	Can be used
days	the method header (parameter)	anywhere in total
sum	the method body	from its declaration to the end of total
day	the for loop header	only inside the loop
rain	the loop body	only inside the loop body

Using a loop variable after the loop does not compile:

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

Compiler says:

error: cannot find symbol

Watch out: if you need the value after the loop, declare the variable before the loop, in the outer block.

2. Parameters are local variables

Constructors and methods are blocks of code, so their parameters are local variables too 3.8.A.1. A parameter can only be used inside its own constructor or method 3.8.A.1.

public class Thermometer
{
    private double celsius;

    public void setCelsius(double degrees)
    {
        celsius = degrees;
    }

    public double getFahrenheit()
    {
        return degrees * 9 / 5 + 32;
    }
}

Compiler says:

error: cannot find symbol

degrees exists only inside setCelsius. The second method must use the instance variable celsius, which every method of the class can use.

Local variables, including parameters, cannot be declared public or private 3.8.A.1. Access modifiers are only for the members of a class: instance variables, constructors and methods.

public class Profile
{
    private int age;

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

Compiler says:

error: modifier private not allowed here

3. Instance variables vs local variables

	Instance variable	Local variable or parameter
Declared	in the class, outside every method and constructor	in a block, a method header or a constructor header
Can be used	in every constructor and method of the class	only inside its block, constructor or method 3.8.A.1
public/private	yes (usually private)	never 3.8.A.1
Lifetime	as long as the object exists	only while the block runs

4. Same name: the local variable wins

When a local variable or parameter has the same name as an instance variable, the name refers to the local variable, not the instance variable, inside that constructor or method 3.8.A.2. The instance variable is “shadowed”.

This constructor looks right but does nothing useful:

public class Student
{
    private String name;
    private int grade;

    public Student(String name, int grade)
    {
        name = name;     // parameter = parameter
        grade = grade;   // parameter = parameter
    }

    public String toString()
    {
        return name + " (grade " + grade + ")";
    }
}

Student s = new Student("Lina", 10);
System.out.println(s);

Output:

null (grade 0)

Both assignments copy a parameter into itself (println shows the object through its toString method, which is background: writing toString is outside the AP® exam). The instance variables keep their default values, null and 0. Two fixes:

• Give the parameters different names: public Student(String studentName, int studentGrade) with name = studentName;.
• Use the keyword this to name the instance variable: this.name = name; (see topic 3.9).

public class Student
{
    private String name;
    private int grade;

    public Student(String studentName, int studentGrade)
    {
        name = studentName;
        grade = studentGrade;
    }

    public String toString()
    {
        return name + " (grade " + grade + ")";
    }
}

Student s = new Student("Lina", 10);
System.out.println(s);

Output:

Lina (grade 10)

5. A new local variable hides the instance variable

The same rule catches students who add a type in front of an instance variable name inside a method. That declares a new local variable 3.8.A.2.

public class Gamer
{
    private int score;

    public Gamer(int start)
    {
        score = start;
    }

    public void reset()
    {
        int score = 0;   // new local variable, not the instance variable
    }

    public int getScore()
    {
        return score;
    }
}

Gamer g = new Gamer(75);
g.reset();
System.out.println(g.getScore());

Output:

75

The fix is to remove the type: score = 0; assigns to the instance variable.