A Simplified Grammar for Java

The following is a simplified grammar for the Java language, written using BNF notation and taken from the official Java site at java.sun.com. In particular, the following BNF notations are used:

The grammar has been simplified for pedagogical purposes to avoid many of the more complex aspects of the Java language that we won't need to understand until later. It nevertheless covers a fairly large portion of Java and should be useful as an adjunct to the smaller quotations in the text (esp. starting in Chapter 5). (Some of the language features which have been eliminated are: generics, type arguments and type parameters (Java 1.5 features); enumerated constants (a Java 1.5 feature); conditional expressions; instanceOf, exceptions, annotations, interfaces, inner classes, labelled statements, synchronization and assertions; and the "this", "super" and "default" keywords.)

Some of the important broad syntactic categories ("phrase types") in the Java language are:

Finally, here is a list of keywords which have special significance in Java (you shouldn't use these for variable, method or class names):

abstract     assert     boolean     break     byte     case     catch     char     class     const     continue     default    

do     double     else     extends     final     finally     float     for     goto     if     implements     import    

instanceof     int     interface     long     native     new     package     private     protected     public     return     short    

static     strictfp     super     switch     synchronized     this     throw     throws     transient     try     volatile     void     while    

Identifiers and Operators

<qualified identifier>  ::=  <identifier> { . <identifier> }

<literal>  ::=  <int literal> | <float literal> | <char literal> | <string literal> | <bool literal> | <null literal>

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

<prefix op>  ::=  ++ | -- | ! | ~ | + | -

<postfix op>  ::=  ++ | --

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

Expressions

<expression>   ::=  <expression1> [ <assign op> <expression1> ] ]

<expression1>  ::=  <expression2> [ { <infix op> <expression2> } ]

<expression2>  ::=  <prefix op> <expression2> 
              |  ( <type> ) <expression2>
              |  <primary> { <selector> } { <postfix op> }

<primary>  ::=  <literal>
           |  new <creator>
           |  <identifier> { . <identifier> }

<selector>  ::=  . <identifier> [ <arguments> ]
           |  [<expression>]

<arguments>  ::=  ( [ <expression> { , <expression> } ] )

Statements

<block>  ::=  { <block stmts> }

<block stmts>  ::=  { <local var decl stmt> }

<local var decl stmt>  ::=  <type> <var decrs> ;

<statement>  ::= <block>
            | return [ <expression> ] ;
            | if <expression> <statement> [ else <statement> ]
            | switch <expression> { <switch block stmt groups> }
            | for ( <for control> ) <statement>
            | while <expression> <statement>
            | do <statement> while <expression> ;
            | break 
            | continue 
            | <expression> ;
            | ;

Types and variable declarations

<basic type>  ::=  byte | short | char | int | long | float | double | boolean

<type>  ::=   <identifier> { . <identifier> } { [] }  |  <basic type>

<modifier>  ::=  public | protected | private | static | abstract | final
            |  native | synchronized | transient | volatile | strictfp

<var decr>  ::=  <identifier> <var decr rest>

<var decr rest>  ::=  { [] } [ = <var initr> ]

<var decrs>  ::=  <var decr> { , <var decr> }

<var decrs rest>  ::=  <var decr rest> { , <var decr> }

Whole programs ("compilation units")

<compilation unit>  ::=  [ package <qualified identifier> ; ] { <import decl> } { <type decl> }

<import decl>  ::=  import <identifier> { . <identifier> } [ .  *  ] ;

<type decl>  ::=  { <modifier> } <class declaration>

<class declaration>  ::=  class <identifier> [ extends <type> ] <class body>

<class body>  ::=  { { <class body declaration> } }

<class body declaration>  ::=   ;
                      |  [ static ] <block>
                      |  { <modifier> } <member decl>

Method and field declarations

<member decl>  ::=  <method or field decl>
               |  void <identifier> <void method decr rest>
               |  <identifier> <constructor decr rest>

<method or field decl>   ::=  <type> <identifier> <method or field rest>

<method or field rest>   ::=  <var decr rest>  |  <method decr rest>

<method decr rest>       ::=  <formal parameters> { [] } ( <method body> | ; )

<void method decr rest>  ::=  <formal parameters> ( <method body> | ; )

<constructor decr rest>  ::=  <formal parameters> <method body>

<qualified identifier list>  ::=  <qualified identifier> { , <qualified identifier> }


<formal parameters>  ::=  ( [ <formal param decls> ] )

<formal param decls>  ::=  <type> <formal param decls rest>

<formal param decls rest>  ::=  <var declarator id> [ , <formal param decls> ]
                      |  ... <var declarator id>

<var declarator id>  ::=  <identifier> { [] }

<method body>  ::=  <block>

Complex statement forms (for and switch)

<switch block stmt groups>  ::=  { <switch block stmt group> }

<switch block stmt group>  ::=  <switch label> <block stmts>

<switch label>  ::=  case <expression>  |  default

<more stmt exprs>  ::=  { , <stmt expr> }


<for control>  ::=  <for var control>
             |  <for init> ; [ <expression> ] ; [ <for update> ]

<for var control>  ::=  <type> <identifier> <for var control rest>

<for var control rest>  ::=  <var decrs rest> ; [ <expression> ] ; [ <for update> ]
                   |  : <expression>

<for init>  ::=  <expression> <expressions>

Array declarations

<creator>  ::=  <created name> ( <array creator rest> | <class creator rest> )

<created name>  ::=  <identifier> { . <identifier> }

<array creator rest>  ::=  [ ( ] { [] } <array initr> | <expression> ] { [ <expression> ] } { [] } )

<class creator rest>  ::=  <arguments> [ <class body> ]

<array initr>  ::=  { [ <var initr> { , <var initr> } [ , ] ] }

<var initr>  ::=  <array initr> | <expression>