Chapter 6. Names

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 and continue 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 keyword super 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 keyword super 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 leftmost new 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:

• In a field declaration (§8.3, §9.3)

• As the result type of a method (§8.4, §9.4)

• 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 a try 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)