<title> Syntax</title>

<html>
<head>
<title> Syntax</title>
</head>
<body BGCOLOR=#eeeeff text=#000000 LINK=#0000ff VLINK=#000077 ALINK=#ff0000>

<table border="0" width="100%">
<tr>
<td><a href="jTOC.doc.html">Contents</a> | <a href="memory.doc.html">Prev</a> | <a href="jIX.fm.html">Next</a> | <a href="jIX.fm.html">Index</a></td>
<td align=right>Java Language Specification 
Second Edition</td></tr></table>
<hr> 

<a name="52994"></a>

CHAPTER
18 
<a name="52996"></a>
<h1> Syntax</h1>
<hr>
<a name="26238"></a>
This chapter presents a grammar for the Java programming language. 
<a name="26239"></a>
The grammar presented piecemeal in the preceding chapters is much better for exposition, but it is not ideally suited as a basis for a parser. The grammar presented in this chapter is the basis for the reference implementation. 
<a name="57494"></a>
The grammar below uses the following BNF-style conventions:
<ul><a name="57488"></a>
<li>[x] denotes zero or one occurrences of x.
<a name="57492"></a>
<li>{x} denotes zero or more occurrences of x.
<a name="57493"></a>
<li>x | y means one of either x or y.
</ul><a name="44467"></a>
<h2>18.1 The Grammar of the Java Programming Language</h2>
<ul><pre>
Identifier:
IDENTIFIER

QualifiedIdentifier:
Identifier { . Identifier }

Literal:
IntegerLiteral
FloatingPointLiteral
CharacterLiteral
StringLiteral
BooleanLiteral
NullLiteral

Expression:
Expression1 [AssignmentOperator Expression1]]

AssignmentOperator: 
=
+=
-=
*=
/=
&=
|=
^=
%=
<<=
>>=
>>>=

Type:
Identifier { . Identifier } BracketsOpt
BasicType

StatementExpression:
Expression

ConstantExpression:
Expression

Expression1:
Expression2 [Expression1Rest]

Expression1Rest:
[ ? Expression : Expression1]

Expression2 :
Expression3 [Expression2Rest]

Expression2Rest:
{Infixop Expression3}
Expression3 instanceof Type

Infixop:
 ||
 &&
 |
^
 &
 ==
 !=
 <
 >
 <=
 >=
 <<
 >>
 >>>
 +
 -
 *
 /
 %

Expression3:
PrefixOp Expression3
 ( Expr | Type ) Expression3
Primary {Selector} {PostfixOp}

Primary:
 ( Expression )
 this [Arguments]
super SuperSuffix
Literal
new Creator
Identifier { . Identifier }[ IdentifierSuffix]
BasicType BracketsOpt .class
 void.class

IdentifierSuffix:
 [ ( ] BracketsOpt . class | Expression ])
Arguments
. ( class | this | super Arguments | new InnerCreator )

PrefixOp:
 ++
 --
 !
 ~
 +
 -

PostfixOp:
 ++
 --

Selector:
 . Identifier [Arguments]
 . this
. super SuperSuffix
 . new InnerCreator
 [ Expression ]

SuperSuffix:
Arguments
 . Identifier [Arguments]

BasicType:
byte
short
char
int
long
float
double
boolean

ArgumentsOpt:
[ Arguments ]

Arguments:
 ( [Expression { , Expression }] )

BracketsOpt:
{[]}

Creator:
QualifiedIdentifier ( ArrayCreatorRest | ClassCreatorRest )

InnerCreator:
Identifier ClassCreatorRest

ArrayCreatorRest:
 [ ( ] BracketsOpt ArrayInitializer | Expression ] {[ Expression ]}
BracketsOpt )

ClassCreatorRest:
Arguments [ClassBody]

ArrayInitializer:
 { [VariableInitializer {, VariableInitializer} [,]] }

VariableInitializer:
ArrayInitializer
Expression

ParExpression:
 ( Expression )

Block:
 { BlockStatements }

BlockStatements:
{ BlockStatement }

BlockStatement :
LocalVariableDeclarationStatement
ClassOrInterfaceDeclaration
[Identifier :] Statement

LocalVariableDeclarationStatement:
[final] Type VariableDeclarators ;

Statement:
Block
if ParExpression Statement [else Statement]
for ( ForInitOpt ; [Expression] ; ForUpdateOpt ) Statement
while ParExpression Statement
do Statement while ParExpression ;
try Block ( Catches | [Catches] finally Block )
 switch ParExpression { SwitchBlockStatementGroups }
 synchronized ParExpression Block
 return [Expression] ;
throw Expression ;
break [Identifier]
continue [Identifier]
 ;
ExpressionStatement
Identifier : Statement

Catches:
CatchClause {CatchClause}

CatchClause:
 catch ( FormalParameter ) Block

SwitchBlockStatementGroups:
{ SwitchBlockStatementGroup }

SwitchBlockStatementGroup:
SwitchLabel BlockStatements

SwitchLabel:
 case ConstantExpression :
 default:

MoreStatementExpressions:
{ , StatementExpression }

ForInit:
StatementExpression MoreStatementExpressions
[final] Type VariableDeclarators

ForUpdate:
StatementExpression MoreStatementExpressions

ModifiersOpt:
{ Modifier }

Modifier:
public
protected
private
static
abstract
final
native
synchronized
transient
volatile
strictfp

VariableDeclarators:
VariableDeclarator { , VariableDeclarator }

VariableDeclaratorsRest:
VariableDeclaratorRest { , VariableDeclarator }

ConstantDeclaratorsRest:
ConstantDeclaratorRest { , ConstantDeclarator }

VariableDeclarator:
Identifier VariableDeclaratorRest

ConstantDeclarator:
Identifier ConstantDeclaratorRest

VariableDeclaratorRest:
BracketsOpt [ = VariableInitializer]

ConstantDeclaratorRest:
BracketsOpt = VariableInitializer

VariableDeclaratorId:
Identifier BracketsOpt

CompilationUnit:
[package QualifiedIdentifier ; ] {ImportDeclaration}
{TypeDeclaration}

ImportDeclaration:
import Identifier { . Identifier } [ . * ] ;

TypeDeclaration:
ClassOrInterfaceDeclaration
;

ClassOrInterfaceDeclaration:
ModifiersOpt (ClassDeclaration | InterfaceDeclaration)

ClassDeclaration:
class Identifier [extends Type] [implements TypeList] ClassBody

InterfaceDeclaration:
interface Identifier [extends TypeList] InterfaceBody

TypeList:
Type { , Type}

ClassBody:
 { {ClassBodyDeclaration} }

InterfaceBody:
 { {InterfaceBodyDeclaration} }

ClassBodyDeclaration:
 ;
 [static] Block
ModifiersOpt MemberDecl

MemberDecl:
 MethodOrFieldDecl
void Identifier MethodDeclaratorRest
Identifier ConstructorDeclaratorRest
ClassOrInterfaceDeclaration

MethodOrFieldDecl:
 Type Identifier MethodOrFieldRest

MethodOrFieldRest:
 VariableDeclaratorRest
MethodDeclaratorRest

InterfaceBodyDeclaration:
 ;
ModifiersOpt InterfaceMemberDecl

InterfaceMemberDecl:
 InterfaceMethodOrFieldDecl
void Identifier VoidInterfaceMethodDeclaratorRest
ClassOrInterfaceDeclaration

InterfaceMethodOrFieldDecl:
 Type Identifier InterfaceMethodOrFieldRest

InterfaceMethodOrFieldRest:
 ConstantDeclaratorsRest ;
 InterfaceMethodDeclaratorRest

MethodDeclaratorRest:
FormalParameters BracketsOpt [throws QualifiedIdentifierList] (
MethodBody | ; )

VoidMethodDeclaratorRest:
FormalParameters [throws QualifiedIdentifierList] ( MethodBody | ; )

InterfaceMethodDeclaratorRest:
FormalParameters BracketsOpt [throws QualifiedIdentifierList] ;

VoidInterfaceMethodDeclaratorRest:
FormalParameters [throws QualifiedIdentifierList] ;

ConstructorDeclaratorRest:
FormalParameters [throws QualifiedIdentifierList] MethodBody

QualifiedIdentifierList:
QualifiedIdentifier { , QualifiedIdentifier}

FormalParameters:
 ( [FormalParameter { , FormalParameter}] )

FormalParameter:
[final] Type VariableDeclaratorId

MethodBody:
Block
</pre></ul>

<hr>
<table border="0" width="100%">
<tr>
<td><a href="jTOC.doc.html">Contents</a> | <a href="memory.doc.html">Prev</a> | <a href="jIX.fm.html">Next</a> | <a href="jIX.fm.html">Index</a></td>
<td align=right>Java Language Specification 
Second Edition</td></tr></table>
<a href="jcopyright.doc.html">Copyright</a> &#169 2000 Sun Microsystems, Inc.
All rights reserved
 
Please send any comments or corrections to <a href="mailto:[email protected]">[email protected]</a>

</body></html>