6.2. Names and Identifiers
A name is used to refer to an entity declared in a program.
There are two forms of names: simple names and qualified names.
A simple name is a single identifier.
A qualified name consists of a name, a ".
" token, and an identifier.
In determining the meaning of a name (§6.5), the context in which the name appears is taken into account. The rules of §6.5 distinguish among contexts where a name must denote (refer to) a package (§6.5.3), a type (§6.5.5), a variable or value in an expression (§6.5.6), or a method (§6.5.7).
Packages and reference types have members which may be accessed by qualified names. As background for the discussion of qualified names and the determination of the meaning of names, see the descriptions of membership in §4.4, §4.5.2, §4.8, §4.9, §7.1, §8.2, §9.2, and §10.7.
Not all identifiers in a program are a part of a name. Identifiers are also used in the following situations:
In declarations (§6.1), where an identifier may occur to specify the name by which the declared entity will be known.
As labels in labeled statements (§14.7) and in
break
andcontinue
statements (§14.15, §14.16) that refer to statement labels.In field access expressions (§15.11), where an identifier occurs after a "
.
" token to indicate a member of an object that is the value of an expression or the keywordsuper
that appears before the ".
" token
FieldAccess: Primary . Identifier super . Identifier ClassName . super . Identifier
In some method invocation expressions (§15.12), where an identifier may occur after a "
.
" token and before a "(
" token to indicate a method to be invoked for an object that is the value of an expression or the keywordsuper
that appears before the ".
" token
MethodInvocation: MethodName ( ArgumentListopt ) Primary . NonWildTypeArgumentsopt Identifier ( ArgumentListopt ) super . NonWildTypeArgumentsopt Identifier ( ArgumentListopt ) ClassName . super . NonWildTypeArgumentsopt Identifier ( ArgumentListopt ) TypeName . NonWildTypeArguments Identifier ( ArgumentListopt )
In qualified class instance creation expressions (§15.9), where an identifier occurs immediately to the right of the leftmost
new
token to indicate a type that must be a member of the compile-time type of the primary expression preceding the ".
" preceding the leftmostnew
token.
ClassInstanceCreationExpression: new TypeArgumentsopt TypeDeclSpecifier TypeArgumentsOrDiamondopt ( ArgumentListopt ) ClassBodyopt Primary . new TypeArgumentsopt Identifier TypeArgumentsOrDiamondopt ( ArgumentListopt ) ClassBodyopt TypeArgumentsOrDiamond: TypeArguments <> ArgumentList: Expression ArgumentList , Expression
Names are used to refer to entities declared in a program.
A declared entity (§6.1) is a
(1)package
(2)class type (normal or enum)
(3)interface type (normal or annotation type)
(4)member (class, interface, field, or method) of a reference type
(5)type parameter (of a class, interface, method or constructor)
(6)parameter (to a method, constructor, or exception handler),
(7)local variable
6.5. Determining the Meaning of a Name
The meaning of a name depends on the context in which it is used. The determination of the meaning of a name requires three steps:
First, context causes a name syntactically to fall into one of six categories: PackageName, TypeName, ExpressionName, MethodName, PackageOrTypeName, or AmbiguousName.
Second, a name that is initially classified by its context as an AmbiguousName or as a PackageOrTypeName is then reclassified to be a PackageName, TypeName, or ExpressionName.
Third, the resulting category then dictates the final determination of the meaning of the name (or a compile-time error if the name has no meaning).
PackageName: Identifier PackageName . Identifier TypeName: Identifier PackageOrTypeName . Identifier ExpressionName: Identifier AmbiguousName . Identifier MethodName: Identifier AmbiguousName . Identifier PackageOrTypeName: Identifier PackageOrTypeName . Identifier AmbiguousName: Identifier AmbiguousName . Identifier
6.5.1. Syntactic Classification of a Name According to Context
1、A name is syntactically classified as a PackageName in these contexts:
(1)In a package declaration (§7.4)
PackageDeclaration: Annotationsopt package PackageName ;
(2)To the left of the ".
" in a qualified PackageName
2、A name is syntactically classified as a TypeName in these contexts:
(1)In a single-type-import declaration (§7.5.1)
SingleTypeImportDeclaration: import TypeName ;
(2)To the left of the ".
" in a single-static-import declaration (§7.5.3)
SingleStaticImportDeclaration: import static TypeName . Identifier ;
(3)To the left of the ".
" in a static-import-on-demand declaration (§7.5.4)
StaticImportOnDemandDeclaration: import static TypeName . * ;
(4)To the left of the "<
" in a parameterized type (§4.5)
(5)In a type argument list (§4.5.1) of a parameterized type
TypeArguments: < TypeArgumentList > TypeArgumentList: TypeArgument TypeArgumentList , TypeArgument TypeArgument: ReferenceType Wildcard Wildcard: ? WildcardBoundsopt WildcardBounds: extends ReferenceType super ReferenceType
(6)In an explicit type argument list in a method or constructor invocation
(7)In an extends
clause in a type variable declaration (§8.1.2)
(8)In an extends
clause of a wildcard type argument (§4.5.1)
(9)In a super
clause of a wildcard type argument (§4.5.1)
(10)In an extends
clause in a class declaration (§8.1.4)
(11)In an implements
clause in a class declaration (§8.1.5)
(12)In an extends
clause in an interface declaration (§9.1.3)
(13)After the "@
" sign in an annotation (§9.7)
(14)As a Type (or the part of a Type that remains after all毕竟,终究 brackets are deleted) in any of the following contexts:
As the type of a formal parameter of a method or constructor (§8.4.1, §8.8.1, §9.4)
As the type of an exception that can be thrown by a method or constructor (§8.4.6, §8.8.5, §9.4)
As the type of a local variable (§14.4)
As the type of an exception parameter in a
catch
clause of atry
statement (§14.20)As the type in a class literal (§15.8.2)
As the qualifying type of a qualified
this
expression (§15.8.4).As the class type which is to be instantiated in an unqualified class instance creation expression (§15.9)
As the direct superclass or direct superinterface of an anonymous class (§15.9.5) which is to be instantiated in an unqualified class instance creation expression (§15.9)
As the element type of an array to be created in an array creation expression (§15.10)
As the qualifying type of field access using the keyword
super
(§15.11.2)As the qualifying type of a method invocation using the keyword
super
(§15.12)As the type mentioned in the cast operator of a cast expression (§15.16)
As the type that follows the
instanceof
relational operator (§15.20.2)
3、A name is syntactically classified as an ExpressionName in these contexts:
(1)As the qualifying expression in a qualified superclass constructor invocation (§8.8.7.1)
(2)As the qualifying expression in a qualified class instance creation expression (§15.9)
(3)As the array reference expression in an array access expression (§15.13)
(4)As a PostfixExpression (§15.14)
(5)As the left-hand operand of an assignment operator (§15.26)
4、A name is syntactically classified as a MethodName in these contexts:
(1)Before the "(
" in a method invocation expression (§15.12)
(2)To the left of the "=
" sign in an annotation's element value pair (§9.7)
5、A name is syntactically classified as a PackageOrTypeName in these contexts:
(1)To the left of the ".
" in a qualified TypeName
(2)In a type-import-on-demand declaration (§7.5.2)
6、A name is syntactically classified as an AmbiguousName in these contexts:
(1)To the left of the ".
" in a qualified ExpressionName
(2)To the left of the ".
" in a qualified MethodName
(3)To the left of the ".
" in a qualified AmbiguousName
(4)In the default value clause of an annotation type element declaration (§9.6)
(5)To the right of an "=
" in an an element value pair (§9.7)