In Java, when you declare a variable, the variable has an associated scope: the region of code for which that variable and its value are accessible. Specifically, the scope of a variable is determined by the block of code in which the variable is declared. Here, a block is a section of code contained between an opening curly brace { and its closing curly brace }.
Consider the following simple(useless) class, ScopeTest:
publicclassScopeTest {
privatestaticint a = 1;
publicstaticvoidmain(String[] args){
int b = 2;
if (b == 2) {
int c = 3;
}
}
}
Within the class ScopeTest there are 3 different scopes: scope 1 the scope between lines 1 and 10, where int a is declared, scope 2 between lines 4 and 9 within the main method where int b is declared, and scope 3 between lines 6 and 8 where int c is declared.
Each variable is accessible only within its scope. For example, the following modification of ScopeTest will result in an error:
publicclassScopeTest {
privatestaticint a = 1;
publicstaticvoidmain(String[] args){
int b = 2;
if (b == 2) {
int c = 3;
}
b = c; // ERROR: c was not declared in this scope!
}
}
Notice that the three scopes in ScopeTest are nested: the scope of c is contained within the scope of b which is contained within the scope of a.
Now for a bit of a behind-the-scenes view of what Java is doing with these variables. When your code is executing, Java maintains a table of variable names and their corresponding values for each scope separately. When a statement uses the value of a variable, Java first checks the innermost scope containing the statement for the required variable name/value. If the variable was not declared in the innermost scope, it then checks the next larger scope. This process continues until the outermost scope is reached.(You will get an error if the variable name is not found in any scope.)
For example, consider the following code:
publicclassScopeTest {
privatestaticint a = 1;
publicstaticvoidmain(String[] args){
int b = 2;
if (b == 2) {
int c = 3;
System.out.println("a = " + a);
}
}
}
When executing the statement System.out.println("a = " + a);. Java needs to look up the value of a. It will first check the innermost scope containing line 8—scope 3(lines 6–9) for a variable a. There is no variable called adeclared in scope 3, so Java next checks scope 2(lines 4–10). Again, there is no variable a declare in scope 2, so it finally checks scope 1(lines 1–11). This is where a is declared, and its value is 1, so the program above will output a = 1.
Java will complain if you declare two variables with the same name in the same scope, but you are allowed to declare variables with the same names in different scopes. When looking up values of variables, Java will always look up variable names in scopes starting with the innermost scope containing the statement the variable and ending with the outermost.
Exercise. The following modification of ScopeTest is perfectly valid. What does it output?
publicclassScopeTest {
privatestaticint a = 1;
publicstaticvoidmain(String[] args){
int a = 2;
if (a == 2) {
int c = 3;
System.out.println("a = " + a);
}
}
}
Challenge. If you wanted to access the value of a declared/assigned in line 2 from within the main method, how would you do it?
Scopes and methods; passing by value
Consider the following extension of ScopeTest:
publicclassScopeTest{
privatestaticint a = 1;
publicstaticvoidfoo(int d){
if (d == 2) {
int e = 5;
}
}
publicstaticvoidmain(String[] args){
int b = 2;
if (b == 2) {
int c = 3;
foo(c);
}
}
}
There are now 5 different scopes!:
Scope 1, where a is declared(lines 1–17)
Scope 2, where b is declared(lines 10–16)
Scope 3, where c is declared(lines 12–15)
Scope 4, where d(the argument to foo) is declared(lines 4–8)
Scope 5, where e is declared(lines 5–7)
Note that the scope of an argument to a method is the entire method.
Unlike the previous example, some of the scopes above are non-overlapping—specifically scopes 2 and 3 do not overlap with scopes 4 and 5.
Notice that in line 14, the method foo is called with argument c. When foo is executed the, c is not in the scope of foo(scope 4). The way Java handles this function call is that a new variable d(the argument of foo) is created, and the value passed to foo(i.e., the value of c in line 14) is copied and stored as the value of d, whose scope starts at line 4. This behavior—of copying the value passed to a method, and storing that value in a new variable—is called passing by value. In Java, all functions calls are pass by value.
Once again, we can reuse variable names so long as the variables are declared in different scopes. Note, however, that we get an error in line 9 because e is not in the scope of this line.
publicclassScopeTest{
privatestaticint a = 1;
publicstaticvoidfoo(int a){
if (a == 2) {
int e = 5;
System.out.println("e = " + e);
}
System.out.println("e = " + e);
}
publicstaticvoidbar(){
foo(a);
}
publicstaticvoidmain(String[] args){
int a = 2;
if (a == 2) {
int c = 3;
foo(a);
}
bar();
}
}
Exercise. What is the output of the program above?
Scopes of variables
public class ScopeTest { private static int a = 1;
public static void main(String[] args) { int b = 2; if (b == 2) { int c = 3; } }}public class ScopeTest { private static int a = 1;
public static void main(String[] args) { int b = 2; if (b == 2) { int c = 3; } b = c; // ERROR: c was not declared in this scope! }}public class ScopeTest { private static int a = 1;
public static void main(String[] args) { int b = 2; if (b == 2) { int c = 3; System.out.println("a = " + a); } }}public class ScopeTest { private static int a = 1;
public static void main(String[] args) { int a = 2; if (a == 2) { int c = 3; System.out.println("a = " + a); } }}Scopes and methods; passing by value
public class ScopeTest { private static int a = 1;
public static void foo (int d) { if (d == 2) { int e = 5; } }
public static void main(String[] args) { int b = 2; if (b == 2) { int c = 3; foo(c); } }}public class ScopeTest { private static int a = 1;
public static void foo (int a) { if (a == 2) { int e = 5; System.out.println("e = " + e); } System.out.println("e = " + e); }
public static void bar () { foo(a); }
public static void main(String[] args) { int a = 2; if (a == 2) { int c = 3; foo(a); } bar(); }}