CHAPTER 6: Names

Previous

Java Language

Index

Next

6.3 Scope of a Simple Name

The scope of a declaration is the region of the program within which the entity declared by the declaration can be referred to using a simple name:

• The scope of a package, as introduced by a package declaration, is determined by the host system (S7.4.3). All Java code is within the scope of the standard package named java , so the package java can always be referred to by Java code.
• The scope of a type imported by a single-type-import declaration (S7.5.1) or type-import-on-demand declaration (S7.5.2) is all the class and interface type declarations (S7.6) in the compilation unit in which the import declaration appears.
• The scope of a type introduced by a class type declaration (S8.1.1) or interface type declaration (S9.1.1) is the declarations of all class and interface types in all the compilation units (S7.3) of the package in which it is declared.
• The scope of a member declared in or inherited by a class type (S8.2) or interface type (S9.2) is the entire declaration of the class or interface type. The declaration of a member needs to appear before it is used only when the use is in a field initialization expression (S8.3.2, S12.4.2, S12.5). This means that a compile-time error results from the test program:

	class Test {
		int i = j;				// compile-time error: incorrect forward reference
		int j = 1;
	}

whereas the following example compiles without error:

	class Test {
		Test() { k = 2; }
		int j = 1;
		int i = j;
		int k;
	}

even though the constructor (S8.6) for Test refers to the field k that is declared three lines later.

• The scope of a parameter of a method (S8.4.1) is the entire body of the method.

• The scope of a parameter of a constructor (S8.6.1) is the entire body of the constructor.
• The scope of a local variable declaration in a block (S14.3.2) is the rest of the block in which the declaration appears, starting with its own initializer (S14.3) and including any further declarators to the right in the local variable declaration statement.
• The scope of a local variable declared in the ForInit part of a for statement (S14.12) includes all of the following:
  • Its own initializer
  • Any further declarators to the right in the ForInit part of the for statement
  • The Expression and ForUpdate parts of the for statement
  • The contained Statement
• The scope of a parameter of an exception handler that is declared in a catch clause of a try statement (S14.18) is the entire block associated with the catch .

These rules imply that declarations of class and interface types need not appear before uses of the types.

In the example:

package points;

class Point {
	int x, y;
	PointList list;
	Point next;
}

class PointList {
	Point first;
}

the use of PointList in class Point is correct, because the scope of the class type name PointList includes both class Point and class PointList , as well as any other type declarations in other compilation units of package points .

6.3.1 Hiding Names

Some declarations may be hidden (S6.3.1) in part of their scope by another declaration of the same name, in which case a simple name cannot be used to refer to the declared entity.

The example:

class Test {
	static int x = 1;
	public static void main(String[] args) {
		int x = 0;
		System.out.print("x=" + x);
		System.out.println(", Test.x=" + Test.x);
	}
}

produces the output:

x=0, Test.x=1

This example declares:

• a class Test
• a class (static ) variable x that is a member of the class Test
• a class method main that is a member of the class Test
• a parameter args of the main method
• a local variable x of the main method

Since the scope of a class variable includes the entire body of the class (S8.2) the class variable x would normally be available throughout the entire body of the method main . In this example, however, the class variable x is hidden within the body of the method main by the declaration of the local variable x .

A local variable has as its scope the rest of the block in which it is declared (S14.3.2); in this case this is the rest of the body of the main method, namely its initializer "0 " and the invocations of print and println .

This means that:

• The expression "x " in the invocation of print refers to (denotes) the value of the local variable x .
• The invocation of println uses a qualified name (S6.6) Test.x , which uses the class type name Test to access the class variable x , because the declaration of Test.x is hidden at this point and cannot be referred to by its simple name.

If the standard naming conventions (S6.8) are followed, then hiding that would make the identification of separate naming contexts matter should be rare. The following contrived example involves hiding because it does not follow the standard naming conventions:

class Point { int x, y; }

class Test {

	static Point Point(int x, int y) {
		Point p = new Point();
		p.x = x; p.y = y;
		return p;
	}


	public static void main(String[] args) {
		int Point;
		Point[] pa = new Point[2];
		for (Point = 0; Point < 2; Point++) {
			pa[Point] = new Point();
			pa[Point].x = Point;
			pa[Point].y = Point;
		}
		System.out.println(pa[0].x + "," + pa[0].y);
		System.out.println(pa[1].x + "," + pa[1].y);
		Point p = Point(3, 4);
		System.out.println(p.x + "," + p.y);
	}

}

This compiles without error and executes to produce the output:

0,0
1,1

3,4

Within the body of main , the lookups of Point find different declarations depending on the context of the use:

• In the expression "new Point[2] ", the two occurrences of the class instance creation expression "new Point() ", and at the start of three different local variable declaration statements, the Point is a TypeName (S6.5.4) and denotes the class type Point in each case.
• In the method invocation expression "Point(3, 4) " the occurrence of Point is a MethodName (S6.5.6) and denotes the class (static ) method Point .
• All other names are ExpressionNames (S6.5.5) and refer to the local variable Point .

The example:

import java.util.*;

class Vector {
	int val[] = { 1 , 2 };
}


class Test {
	public static void main(String[] args) {
		Vector v = new Vector();
		System.out.println(v.val[0]);
	}
}

compiles and prints:

1

using the class Vector declared here in preference to class java.util.Vector that might be imported on demand.