.JAVA File Format – Syntax

Java source code

This page is the whole grammar of a Java source file, production by production, from chapter 19 of The Java Language Specification, Java SE 27 Edition. That chapter repeats the syntactic grammar of chapters 4, 6 to 10, 14 and 15, and the key lexical productions of chapter 3. The other pages of this reference explain what each construct means.

Notation

  • The name before a colon is the production being defined. Each line below it is one alternative.
  • [x] means zero or one x, and {x} means zero or more. Where the braces and brackets stand for themselves, as around a class body or array dimensions, they are shown as such; the Java tokens are also marked by their position, so ClassBody: below is a { token, then a list, then a } token.
  • (one of) means any single token on the lines that follow.
  • Comments and white space may go between any two tokens; they are not in the grammar. The tokens themselves are defined on the Lexical structure page.

Lexical productions (JLS 3)

Identifier:
    IdentifierChars but not a ReservedKeyword or BooleanLiteral or NullLiteral

IdentifierChars:
    JavaLetter {JavaLetterOrDigit}

JavaLetter:
    any Unicode character that is a "Java letter"

JavaLetterOrDigit:
    any Unicode character that is a "Java letter-or-digit"

TypeIdentifier:
    Identifier but not permits, record, sealed, var, or yield

UnqualifiedMethodIdentifier:
    Identifier but not yield

Literal:
    IntegerLiteral
    FloatingPointLiteral
    BooleanLiteral
    CharacterLiteral
    StringLiteral
    TextBlock
    NullLiteral

Types, values and variables (JLS 4)

Type:
    PrimitiveType
    ReferenceType

PrimitiveType:
    {Annotation} NumericType
    {Annotation} boolean

NumericType:
    IntegralType
    FloatingPointType

IntegralType: (one of)
    byte short int long char

FloatingPointType: (one of)
    float double

ReferenceType:
    ClassOrInterfaceType
    TypeVariable
    ArrayType

ClassOrInterfaceType:
    ClassType
    InterfaceType

ClassType:
    {Annotation} TypeIdentifier [TypeArguments]
    PackageName . {Annotation} TypeIdentifier [TypeArguments]
    ClassOrInterfaceType . {Annotation} TypeIdentifier [TypeArguments]

InterfaceType:
    ClassType

TypeVariable:
    {Annotation} TypeIdentifier

ArrayType:
    PrimitiveType Dims
    ClassOrInterfaceType Dims
    TypeVariable Dims

Dims:
    {Annotation} [ ] {{Annotation} [ ]}

TypeParameter:
    {TypeParameterModifier} TypeIdentifier [TypeBound]

TypeParameterModifier:
    Annotation

TypeBound:
    extends TypeVariable
    extends ClassOrInterfaceType {AdditionalBound}

AdditionalBound:
    & InterfaceType

TypeArguments:
    < TypeArgumentList >

TypeArgumentList:
    TypeArgument {, TypeArgument}

TypeArgument:
    ReferenceType
    Wildcard

Wildcard:
    {Annotation} ? [WildcardBounds]

WildcardBounds:
    extends ReferenceType
    super ReferenceType

Names (JLS 6)

ModuleName:
    Identifier
    ModuleName . Identifier

PackageName:
    Identifier
    PackageName . Identifier

TypeName:
    TypeIdentifier
    PackageOrTypeName . TypeIdentifier

ExpressionName:
    Identifier
    AmbiguousName . Identifier

MethodName:
    UnqualifiedMethodIdentifier

PackageOrTypeName:
    Identifier
    PackageOrTypeName . Identifier

AmbiguousName:
    Identifier
    AmbiguousName . Identifier

Packages and modules (JLS 7)

CompilationUnit:
    OrdinaryCompilationUnit
    CompactCompilationUnit
    ModularCompilationUnit

OrdinaryCompilationUnit:
    [PackageDeclaration] {ImportDeclaration} {TopLevelClassOrInterfaceDeclaration}

CompactCompilationUnit:
    {ImportDeclaration} {ClassMemberDeclarationNoMethod} MethodDeclaration {ClassMemberDeclaration}

ClassMemberDeclarationNoMethod:
    FieldDeclaration
    ClassDeclaration
    InterfaceDeclaration
    ;

ModularCompilationUnit:
    {ImportDeclaration} ModuleDeclaration

PackageDeclaration:
    {PackageModifier} package Identifier {. Identifier} ;

PackageModifier:
    Annotation

ImportDeclaration:
    SingleTypeImportDeclaration
    TypeImportOnDemandDeclaration
    SingleStaticImportDeclaration
    StaticImportOnDemandDeclaration
    SingleModuleImportDeclaration

SingleTypeImportDeclaration:
    import TypeName ;

TypeImportOnDemandDeclaration:
    import PackageOrTypeName . * ;

SingleStaticImportDeclaration:
    import static TypeName . Identifier ;

StaticImportOnDemandDeclaration:
    import static TypeName . * ;

SingleModuleImportDeclaration:
    import module ModuleName ;

TopLevelClassOrInterfaceDeclaration:
    ClassDeclaration
    InterfaceDeclaration
    ;

ModuleDeclaration:
    {Annotation} [open] module Identifier {. Identifier} { {ModuleDirective} }

ModuleDirective:
    requires {RequiresModifier} ModuleName ;
    exports PackageName [to ModuleName {, ModuleName}] ;
    opens PackageName [to ModuleName {, ModuleName}] ;
    uses TypeName ;
    provides TypeName with TypeName {, TypeName} ;

RequiresModifier: (one of)
    transitive static

Classes (JLS 8)

ClassDeclaration:
    NormalClassDeclaration
    EnumDeclaration
    RecordDeclaration

NormalClassDeclaration:
    {ClassModifier} class TypeIdentifier [TypeParameters] [ClassExtends] [ClassImplements] [ClassPermits] ClassBody

ClassModifier: (one of)
    Annotation public protected private
    abstract static final sealed non-sealed strictfp

TypeParameters:
    < TypeParameterList >

TypeParameterList:
    TypeParameter {, TypeParameter}

ClassExtends:
    extends ClassType

ClassImplements:
    implements InterfaceTypeList

InterfaceTypeList:
    InterfaceType {, InterfaceType}

ClassPermits:
    permits TypeName {, TypeName}

ClassBody:
    { {ClassBodyDeclaration} }

ClassBodyDeclaration:
    ClassMemberDeclaration
    InstanceInitializer
    StaticInitializer
    ConstructorDeclaration

ClassMemberDeclaration:
    FieldDeclaration
    MethodDeclaration
    ClassDeclaration
    InterfaceDeclaration
    ;

FieldDeclaration:
    {FieldModifier} UnannType VariableDeclaratorList ;

FieldModifier: (one of)
    Annotation public protected private
    static final transient volatile

VariableDeclaratorList:
    VariableDeclarator {, VariableDeclarator}

VariableDeclarator:
    VariableDeclaratorId [= VariableInitializer]

VariableDeclaratorId:
    Identifier [Dims]
    _

VariableInitializer:
    Expression
    ArrayInitializer

UnannType:
    UnannPrimitiveType
    UnannReferenceType

UnannPrimitiveType:
    NumericType
    boolean

UnannReferenceType:
    UnannClassOrInterfaceType
    UnannTypeVariable
    UnannArrayType

UnannClassOrInterfaceType:
    UnannClassType
    UnannInterfaceType

UnannClassType:
    TypeIdentifier [TypeArguments]
    PackageName . {Annotation} TypeIdentifier [TypeArguments]
    UnannClassOrInterfaceType . {Annotation} TypeIdentifier [TypeArguments]

UnannInterfaceType:
    UnannClassType

UnannTypeVariable:
    TypeIdentifier

UnannArrayType:
    UnannPrimitiveType Dims
    UnannClassOrInterfaceType Dims
    UnannTypeVariable Dims

MethodDeclaration:
    {MethodModifier} MethodHeader MethodBody

MethodModifier: (one of)
    Annotation public protected private
    abstract static final synchronized native strictfp

MethodHeader:
    Result MethodDeclarator [Throws]
    TypeParameters {Annotation} Result MethodDeclarator [Throws]

Result:
    UnannType
    void

MethodDeclarator:
    Identifier ( [ReceiverParameter ,] [FormalParameterList] ) [Dims]

ReceiverParameter:
    {Annotation} UnannType [Identifier .] this

FormalParameterList:
    FormalParameter {, FormalParameter}

FormalParameter:
    {VariableModifier} UnannType VariableDeclaratorId
    VariableArityParameter

VariableArityParameter:
    {VariableModifier} UnannType {Annotation} ... Identifier

VariableModifier:
    Annotation
    final

Throws:
    throws ExceptionTypeList

ExceptionTypeList:
    ExceptionType {, ExceptionType}

ExceptionType:
    ClassType
    TypeVariable

MethodBody:
    Block
    ;

InstanceInitializer:
    Block

StaticInitializer:
    static Block

ConstructorDeclaration:
    {ConstructorModifier} ConstructorDeclarator [Throws] ConstructorBody

ConstructorModifier: (one of)
    Annotation public protected private

ConstructorDeclarator:
    [TypeParameters] SimpleTypeName ( [ReceiverParameter ,] [FormalParameterList] )

SimpleTypeName:
    TypeIdentifier

ConstructorBody:
    { [BlockStatements] ConstructorInvocation [BlockStatements] }
    { [BlockStatements] }

ConstructorInvocation:
    [TypeArguments] this ( [ArgumentList] ) ;
    [TypeArguments] super ( [ArgumentList] ) ;
    ExpressionName . [TypeArguments] super ( [ArgumentList] ) ;
    Primary . [TypeArguments] super ( [ArgumentList] ) ;

EnumDeclaration:
    {ClassModifier} enum TypeIdentifier [ClassImplements] EnumBody

EnumBody:
    { [EnumConstantList] [,] [EnumBodyDeclarations] }

EnumConstantList:
    EnumConstant {, EnumConstant}

EnumConstant:
    {EnumConstantModifier} Identifier [( [ArgumentList] )] [ClassBody]

EnumConstantModifier:
    Annotation

EnumBodyDeclarations:
    ; {ClassBodyDeclaration}

RecordDeclaration:
    {ClassModifier} record TypeIdentifier [TypeParameters] RecordHeader [ClassImplements] RecordBody

RecordHeader:
    ( [RecordComponentList] )

RecordComponentList:
    RecordComponent {, RecordComponent}

RecordComponent:
    {RecordComponentModifier} UnannType Identifier
    VariableArityRecordComponent

VariableArityRecordComponent:
    {RecordComponentModifier} UnannType {Annotation} ... Identifier

RecordComponentModifier:
    Annotation

RecordBody:
    { {RecordBodyDeclaration} }

RecordBodyDeclaration:
    ClassBodyDeclaration
    CompactConstructorDeclaration

CompactConstructorDeclaration:
    {ConstructorModifier} SimpleTypeName ConstructorBody

Interfaces (JLS 9)

InterfaceDeclaration:
    NormalInterfaceDeclaration
    AnnotationInterfaceDeclaration

NormalInterfaceDeclaration:
    {InterfaceModifier} interface TypeIdentifier [TypeParameters] [InterfaceExtends] [InterfacePermits] InterfaceBody

InterfaceModifier: (one of)
    Annotation public protected private
    abstract static sealed non-sealed strictfp

InterfaceExtends:
    extends InterfaceTypeList

InterfacePermits:
    permits TypeName {, TypeName}

InterfaceBody:
    { {InterfaceMemberDeclaration} }

InterfaceMemberDeclaration:
    ConstantDeclaration
    InterfaceMethodDeclaration
    ClassDeclaration
    InterfaceDeclaration
    ;

ConstantDeclaration:
    {ConstantModifier} UnannType VariableDeclaratorList ;

ConstantModifier: (one of)
    Annotation public
    static final

InterfaceMethodDeclaration:
    {InterfaceMethodModifier} MethodHeader MethodBody

InterfaceMethodModifier: (one of)
    Annotation public private
    abstract default static strictfp

AnnotationInterfaceDeclaration:
    {InterfaceModifier} @ interface TypeIdentifier AnnotationInterfaceBody

AnnotationInterfaceBody:
    { {AnnotationInterfaceMemberDeclaration} }

AnnotationInterfaceMemberDeclaration:
    AnnotationInterfaceElementDeclaration
    ConstantDeclaration
    ClassDeclaration
    InterfaceDeclaration
    ;

AnnotationInterfaceElementDeclaration:
    {AnnotationInterfaceElementModifier} UnannType Identifier ( ) [Dims] [DefaultValue] ;

AnnotationInterfaceElementModifier: (one of)
    Annotation public
    abstract

DefaultValue:
    default ElementValue

Annotation:
    NormalAnnotation
    MarkerAnnotation
    SingleElementAnnotation

NormalAnnotation:
    @ TypeName ( [ElementValuePairList] )

ElementValuePairList:
    ElementValuePair {, ElementValuePair}

ElementValuePair:
    Identifier = ElementValue

ElementValue:
    ConditionalExpression
    ElementValueArrayInitializer
    Annotation

ElementValueArrayInitializer:
    { [ElementValueList] [,] }

ElementValueList:
    ElementValue {, ElementValue}

MarkerAnnotation:
    @ TypeName

SingleElementAnnotation:
    @ TypeName ( ElementValue )

Arrays (JLS 10)

ArrayInitializer:
    { [VariableInitializerList] [,] }

VariableInitializerList:
    VariableInitializer {, VariableInitializer}

Blocks, statements and patterns (JLS 14)

Block:
    { [BlockStatements] }

BlockStatements:
    BlockStatement {BlockStatement}

BlockStatement:
    LocalClassOrInterfaceDeclaration
    LocalVariableDeclarationStatement
    Statement

LocalClassOrInterfaceDeclaration:
    ClassDeclaration
    NormalInterfaceDeclaration

LocalVariableDeclarationStatement:
    LocalVariableDeclaration ;

LocalVariableDeclaration:
    {VariableModifier} LocalVariableType VariableDeclaratorList

LocalVariableType:
    UnannType
    var

Statement:
    StatementWithoutTrailingSubstatement
    LabeledStatement
    IfThenStatement
    IfThenElseStatement
    WhileStatement
    ForStatement

StatementNoShortIf:
    StatementWithoutTrailingSubstatement
    LabeledStatementNoShortIf
    IfThenElseStatementNoShortIf
    WhileStatementNoShortIf
    ForStatementNoShortIf

StatementWithoutTrailingSubstatement:
    Block
    EmptyStatement
    ExpressionStatement
    AssertStatement
    SwitchStatement
    DoStatement
    BreakStatement
    ContinueStatement
    ReturnStatement
    SynchronizedStatement
    ThrowStatement
    TryStatement
    YieldStatement

EmptyStatement:
    ;

LabeledStatement:
    Identifier : Statement

LabeledStatementNoShortIf:
    Identifier : StatementNoShortIf

ExpressionStatement:
    StatementExpression ;

StatementExpression:
    Assignment
    PreIncrementExpression
    PreDecrementExpression
    PostIncrementExpression
    PostDecrementExpression
    MethodInvocation
    ClassInstanceCreationExpression

IfThenStatement:
    if ( Expression ) Statement

IfThenElseStatement:
    if ( Expression ) StatementNoShortIf else Statement

IfThenElseStatementNoShortIf:
    if ( Expression ) StatementNoShortIf else StatementNoShortIf

AssertStatement:
    assert Expression ;
    assert Expression : Expression ;

SwitchStatement:
    switch ( Expression ) SwitchBlock

SwitchBlock:
    { SwitchRule {SwitchRule} }
    { {SwitchBlockStatementGroup} {SwitchLabel :} }

SwitchRule:
    SwitchLabel -> Expression ;
    SwitchLabel -> Block
    SwitchLabel -> ThrowStatement

SwitchBlockStatementGroup:
    SwitchLabel : {SwitchLabel :} BlockStatements

SwitchLabel:
    case CaseConstant {, CaseConstant}
    case null [, default]
    case CasePattern {, CasePattern} [Guard]
    default

CaseConstant:
    ConditionalExpression

CasePattern:
    Pattern

Guard:
    when Expression

WhileStatement:
    while ( Expression ) Statement

WhileStatementNoShortIf:
    while ( Expression ) StatementNoShortIf

DoStatement:
    do Statement while ( Expression ) ;

ForStatement:
    BasicForStatement
    EnhancedForStatement

ForStatementNoShortIf:
    BasicForStatementNoShortIf
    EnhancedForStatementNoShortIf

BasicForStatement:
    for ( [ForInit] ; [Expression] ; [ForUpdate] ) Statement

BasicForStatementNoShortIf:
    for ( [ForInit] ; [Expression] ; [ForUpdate] ) StatementNoShortIf

ForInit:
    StatementExpressionList
    LocalVariableDeclaration

ForUpdate:
    StatementExpressionList

StatementExpressionList:
    StatementExpression {, StatementExpression}

EnhancedForStatement:
    for ( LocalVariableDeclaration : Expression ) Statement

EnhancedForStatementNoShortIf:
    for ( LocalVariableDeclaration : Expression ) StatementNoShortIf

BreakStatement:
    break [Identifier] ;

YieldStatement:
    yield Expression ;

ContinueStatement:
    continue [Identifier] ;

ReturnStatement:
    return [Expression] ;

ThrowStatement:
    throw Expression ;

SynchronizedStatement:
    synchronized ( Expression ) Block

TryStatement:
    try Block Catches
    try Block [Catches] Finally
    TryWithResourcesStatement

Catches:
    CatchClause {CatchClause}

CatchClause:
    catch ( CatchFormalParameter ) Block

CatchFormalParameter:
    {VariableModifier} CatchType VariableDeclaratorId

CatchType:
    UnannClassType {| ClassType}

Finally:
    finally Block

TryWithResourcesStatement:
    try ResourceSpecification Block [Catches] [Finally]

ResourceSpecification:
    ( ResourceList [;] )

ResourceList:
    Resource {; Resource}

Resource:
    LocalVariableDeclaration
    VariableAccess

VariableAccess:
    ExpressionName
    FieldAccess

Pattern:
    TypePattern
    RecordPattern

TypePattern:
    LocalVariableDeclaration

RecordPattern:
    ReferenceType ( [ComponentPatternList] )

ComponentPatternList:
    ComponentPattern {, ComponentPattern}

ComponentPattern:
    Pattern
    MatchAllPattern

MatchAllPattern:
    _

Expressions (JLS 15)

Primary:
    PrimaryNoNewArray
    ArrayCreationExpression

PrimaryNoNewArray:
    Literal
    ClassLiteral
    this
    TypeName . this
    ( Expression )
    ClassInstanceCreationExpression
    FieldAccess
    ArrayAccess
    MethodInvocation
    MethodReference

ClassLiteral:
    TypeName {[ ]} . class
    NumericType {[ ]} . class
    boolean {[ ]} . class
    void . class

ClassInstanceCreationExpression:
    UnqualifiedClassInstanceCreationExpression
    ExpressionName . UnqualifiedClassInstanceCreationExpression
    Primary . UnqualifiedClassInstanceCreationExpression

UnqualifiedClassInstanceCreationExpression:
    new [TypeArguments] ClassOrInterfaceTypeToInstantiate ( [ArgumentList] ) [ClassBody]

ClassOrInterfaceTypeToInstantiate:
    {Annotation} Identifier {. {Annotation} Identifier} [TypeArgumentsOrDiamond]

TypeArgumentsOrDiamond:
    TypeArguments
    <>

ArrayCreationExpression:
    ArrayCreationExpressionWithoutInitializer
    ArrayCreationExpressionWithInitializer

ArrayCreationExpressionWithoutInitializer:
    new PrimitiveType DimExprs [Dims]
    new ClassOrInterfaceType DimExprs [Dims]

ArrayCreationExpressionWithInitializer:
    new PrimitiveType Dims ArrayInitializer
    new ClassOrInterfaceType Dims ArrayInitializer

DimExprs:
    DimExpr {DimExpr}

DimExpr:
    {Annotation} [ Expression ]

ArrayAccess:
    ExpressionName [ Expression ]
    PrimaryNoNewArray [ Expression ]
    ArrayCreationExpressionWithInitializer [ Expression ]

FieldAccess:
    Primary . Identifier
    super . Identifier
    TypeName . super . Identifier

MethodInvocation:
    MethodName ( [ArgumentList] )
    TypeName . [TypeArguments] Identifier ( [ArgumentList] )
    ExpressionName . [TypeArguments] Identifier ( [ArgumentList] )
    Primary . [TypeArguments] Identifier ( [ArgumentList] )
    super . [TypeArguments] Identifier ( [ArgumentList] )
    TypeName . super . [TypeArguments] Identifier ( [ArgumentList] )

ArgumentList:
    Expression {, Expression}

MethodReference:
    ExpressionName :: [TypeArguments] Identifier
    Primary :: [TypeArguments] Identifier
    ReferenceType :: [TypeArguments] Identifier
    super :: [TypeArguments] Identifier
    TypeName . super :: [TypeArguments] Identifier
    ClassType :: [TypeArguments] new
    ArrayType :: new

Expression:
    LambdaExpression
    AssignmentExpression

LambdaExpression:
    LambdaParameters -> LambdaBody

LambdaParameters:
    ( [LambdaParameterList] )
    ConciseLambdaParameter

LambdaParameterList:
    NormalLambdaParameter {, NormalLambdaParameter}
    ConciseLambdaParameter {, ConciseLambdaParameter}

NormalLambdaParameter:
    {VariableModifier} LambdaParameterType VariableDeclaratorId
    VariableArityParameter

LambdaParameterType:
    UnannType
    var

ConciseLambdaParameter:
    Identifier
    _

LambdaBody:
    Expression
    Block

AssignmentExpression:
    ConditionalExpression
    Assignment

Assignment:
    LeftHandSide AssignmentOperator Expression

LeftHandSide:
    ExpressionName
    FieldAccess
    ArrayAccess

AssignmentOperator: (one of)
    =  *=  /=  %=  +=  -=  <<=  >>=  >>>=  &=  ^=  |=

ConditionalExpression:
    ConditionalOrExpression
    ConditionalOrExpression ? Expression : ConditionalExpression
    ConditionalOrExpression ? Expression : LambdaExpression

ConditionalOrExpression:
    ConditionalAndExpression
    ConditionalOrExpression || ConditionalAndExpression

ConditionalAndExpression:
    InclusiveOrExpression
    ConditionalAndExpression && InclusiveOrExpression

InclusiveOrExpression:
    ExclusiveOrExpression
    InclusiveOrExpression | ExclusiveOrExpression

ExclusiveOrExpression:
    AndExpression
    ExclusiveOrExpression ^ AndExpression

AndExpression:
    EqualityExpression
    AndExpression & EqualityExpression

EqualityExpression:
    RelationalExpression
    EqualityExpression == RelationalExpression
    EqualityExpression != RelationalExpression

RelationalExpression:
    ShiftExpression
    RelationalExpression < ShiftExpression
    RelationalExpression > ShiftExpression
    RelationalExpression <= ShiftExpression
    RelationalExpression >= ShiftExpression
    InstanceofExpression

InstanceofExpression:
    RelationalExpression instanceof ReferenceType
    RelationalExpression instanceof Pattern

ShiftExpression:
    AdditiveExpression
    ShiftExpression << AdditiveExpression
    ShiftExpression >> AdditiveExpression
    ShiftExpression >>> AdditiveExpression

AdditiveExpression:
    MultiplicativeExpression
    AdditiveExpression + MultiplicativeExpression
    AdditiveExpression - MultiplicativeExpression

MultiplicativeExpression:
    UnaryExpression
    MultiplicativeExpression * UnaryExpression
    MultiplicativeExpression / UnaryExpression
    MultiplicativeExpression % UnaryExpression

UnaryExpression:
    PreIncrementExpression
    PreDecrementExpression
    + UnaryExpression
    - UnaryExpression
    UnaryExpressionNotPlusMinus

PreIncrementExpression:
    ++ UnaryExpression

PreDecrementExpression:
    -- UnaryExpression

UnaryExpressionNotPlusMinus:
    PostfixExpression
    ~ UnaryExpression
    ! UnaryExpression
    CastExpression
    SwitchExpression

PostfixExpression:
    Primary
    ExpressionName
    PostIncrementExpression
    PostDecrementExpression

PostIncrementExpression:
    PostfixExpression ++

PostDecrementExpression:
    PostfixExpression --

CastExpression:
    ( PrimitiveType ) UnaryExpression
    ( ReferenceType {AdditionalBound} ) UnaryExpressionNotPlusMinus
    ( ReferenceType {AdditionalBound} ) LambdaExpression

SwitchExpression:
    switch ( Expression ) SwitchBlock