The scope of instance and static variables is the entire class, regardless of where the variables are declared. Local variables are declared and used inside a method locally.
This section discusses the scope rules of all the variables in the context of a class. Instance and static variables in a class are referred to as the class’s variables or data fields. A variable defined inside a method is referred to as a local variable. The scope of a class’s variables is the entire class, regardless of where the variables are declared. A class’s variables and methods can appear in any order in the class, as shown in Figure below (a). The exception is when a data field is initialized based on a reference to another data field. In such cases, the other data field must be declared first, as shown in Figure below (b). For consistency, this book declares data fields at the beginning of the class.
You can declare a class’s variable only once, but you can declare the same variable name in a method many times in different nonnesting blocks.
If a local variable has the same name as a class’s variable, the local variable takes precedence and the class’s variable with the same name is hidden. For example, in the following program, x is defined both as an instance variable and as a local variable in the method.
private int x = 0; // Instance variable
private int y = 0;
public F() {
}
public void p() {
int x = 1; // Local variable
System.out.println(“x = ” + x);
System.out.println(“y = ” + y);
}
}
What is the output for f.p(), where f is an instance of F? The output for f.p() is 1 for x and 0 for y. Here is why:
x is declared as a data field with the initial value of 0 in the class, but it is also declared in the method p() with an initial value of 1. The latter x is referenced in the System.out.println statement.
y is declared outside the method p(), but y is accessible inside the method
To avoid confusion and mistakes, do not use the names of instance or static variables as local variable names, except for method parameters
