Scope of a Declaration
6.3 Scope of a Declaration
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, provided it is visible (§6.4.1).
A declaration is said to be in scope at a particular point in a program if and only if the declaration's scope includes that point.
The scope of the declaration of an observable (§7.4.3) top level package is all observable compilation units (§7.3).
The declaration of a package that is not observable is never in scope. The declaration of a subpackage is never in scope. The package java is always in scope. The scope of a type imported by a single-type-import declaration (§7.5.1) or
a type-import-on-demand declaration (§7.5.2) is all the class and interface type declarations (§7.6) in the compilation unit in which the import declaration appears, as well as any annotations on the package declaration (if any) of the compilation unit .
The scope of a member imported by a single-static-import declaration (§7.5.3) or
a static-import-on-demand declaration (§7.5.4) is all the class and interface type declarations (§7.6) in the compilation unit in which the import declaration appears, as well as any annotations on the package declaration (if any) of the compilation unit .
The scope of a top level type (§7.6) is all type declarations in the package in which the top level type is declared.
The scope of a declaration of a member m declared in or inherited by a class type C (§8.1.6) is the entire body of C , including any nested type declarations.
The scope of a declaration of a member m declared in or inherited by an interface type I (§9.1.4) is the entire body of I , including any nested type declarations.
The scope of an enum constant C declared in an enum type T is the body of T , and
any case label of a switch statement whose expression is of enum type T .
NAMES Scope of a Declaration 6.3
The scope of a formal parameter of a method (§8.4.1) or constructor (§8.8.1) is the entire body of the method or constructor.
The scope of a class's type parameter (§8.1.2) is the type parameter section of the class declaration, the type parameter section of any superclass or superinterface of the class declaration, and the class body.
The scope of an interface's type parameter (§9.1.2) is the type parameter section of the interface declaration, the type parameter section of any superinterface of the interface declaration, and the interface body.
The scope of a method's type parameter (§8.4.4) is the entire declaration of the method, including the type parameter section, but excluding the method modifiers.
The scope of a constructor's type parameter (§8.8.4) is the entire declaration of the constructor, including the type parameter section, but excluding the constructor modifiers.
The scope of a local class declaration immediately enclosed by a block (§14.2) is the rest of the immediately enclosing block, including its own class declaration.
The scope of a local class declaration immediately enclosed by a switch block statement group (§14.11) is the rest of the immediately enclosing switch block statement group, including its own class declaration.
The scope of a local variable declaration in a block (§14.4) is the rest of the block in which the declaration appears, starting with its own initializer 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 basic for statement (§14.14.1) 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 local variable declared in the FormalParameter part of an enhanced
for statement (§14.14.2) is the contained Statement. The scope of a parameter of an exception handler that is declared in a catch clause
of a try statement (§14.20) is the entire block associated with the catch . The scope of a variable declared in the ResourceSpecification of a try -with-
resources statement (§14.20.3) is from the declaration rightward over the remainder
6.3 Scope of a Declaration NAMES
of the ResourceSpecification and the entire try block associated with the try -with- resources statement.
The translation of a try -with-resources statement implies the rule above.
Example 6.3-1. Scope and Type Declarations
These rules imply that declarations of class and interface types need not appear before uses of the types. In the following program, the use of PointList in class Point is valid, because the scope of the class declaration PointList includes both class Point and class PointList , as well as any other type declarations in other compilation units of package points .
package points; class Point {
int x, y; PointList list; Point next;
class PointList { Point first; }
Example 6.3-2. Scope of Local Variable Declarations
class Test1 { static int x; public static void main(String[] args) {
int x = x;
This program causes a compile-time error because the initialization of x is within the scope of the declaration of x as a local variable, and the local variable x does not yet have a value and cannot be used.
The following program does compile: class Test2 {
static int x; public static void main(String[] args) {
int x = (x=2)*2; System.out.println(x);
because the local variable x is definitely assigned (§16) before it is used. It prints:
NAMES Shadowing and Obscuring 6.4
In the following program, the initializer for three can correctly refer to the variable two declared in an earlier declarator, and the method invocation in the next line can correctly refer to the variable three declared earlier in the block.
class Test3 { public static void main(String[] args) { System.out.print("2+1="); int two = 2, three = two + 1; System.out.println(three);
This program produces the output: 2+1=3