Class Parser

   AdditiveExpression :=
     MultiplicativeExpression { ( '+' | '-' ) MultiplicativeExpression }
 

   AndExpression :=
     EqualityExpression { '&' EqualityExpression }
 

   ArgumentList := Expression { ',' Expression }
 

   Arguments := '(' [ ArgumentList ] ')'
 

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

   AssignmentExpression :=
     ConditionalExpression [ AssignmentOperator AssignmentExpression ]

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

   '{' BlockStatements '}'
 

   BlockStatement := { Identifier ':' } (
     ( Modifiers Type | ModifiersOpt BasicType ) LocalVariableDeclarators ';' |
     'class' ... |
     Statement |
     'final' Type LocalVariableDeclarators ';' |
     Expression ';' |
     Expression LocalVariableDeclarators ';'   (1)
   )
 

   BlockStatements := { BlockStatement }
 

   BreakStatement := 'break' [ Identifier ] ';'
 

   ClassBody := '{' { ClassBodyDeclaration } '}'
 

   ClassBodyDeclaration :=
     ';' |
     ModifiersOpt (
       Block |                                    // Instance (JLS2 8.6) or static initializer (JLS2 8.7)
       'void' Identifier MethodDeclarationRest |
       'class' ClassDeclarationRest |
       'interface' InterfaceDeclarationRest |
       ConstructorDeclarator |
       Type Identifier (
         MethodDeclarationRest |
         FieldDeclarationRest ';'
       )
     )

 

   ClassDeclarationRest :=
        Identifier
        [ 'extends' ReferenceType ]
        [ 'implements' ReferenceTypeList ]
        ClassBody
 

   CompilationUnit := [ PackageDeclaration ]
                      { ImportDeclaration }
                      { TypeDeclaration }
 

   ConditionalAndExpression :=
     InclusiveOrExpression { '&&' InclusiveOrExpression }
 

   ConditionalExpression :=
     ConditionalOrExpression [ '?' Expression ':' ConditionalExpression ]
 

   ConditionalOrExpression :=
     ConditionalAndExpression { '||' ConditionalAndExpression ]
 

   ConstructorDeclarator :=
     Identifier
     FormalParameters
     [ 'throws' ReferenceTypeList ]
     '{'
       [ 'this' Arguments ';' | 'super' Arguments ';' | Primary '.' 'super' Arguments ';' ]
       BlockStatements
     '}'
 

   ContinueStatement := 'continue' [ Identifier ] ';'
 

   DimExpr := '[' Expression ']'
 

   DimExprs := DimExpr { DimExpr }
 

   DoStatement := 'do' Statement 'while' '(' Expression ')' ';'
 

   EmptyStatement := ';'
 

   EqualityExpression :=
     RelationalExpression { ( '==' | '!=' ) RelationalExpression }
 

   ExclusiveOrExpression :=
     AndExpression { '^' AndExpression }
 

   Expression := AssignmentExpression
 

   ExpressionList := Expression { ',' Expression }
 

   ExpressionStatement := Expression ';'
 

   FieldDeclarationRest :=
     VariableDeclaratorRest
     { ',' VariableDeclarator }
 

   FormalParameter := [ 'final' ] Type Identifier BracketsOpt
 

   FormalParameters := '(' [ FormalParameter { ',' FormalParameter } ] ')'
 

   ForStatement :=
     'for' '('
       [ ForInit ] ';'
       [ Expression ] ';'
       [ ExpressionList ]
     ')' Statement
 

   IfStatement := 'if' '(' Expression ')' Statement [ 'else' Statement ]
 

   ImportDeclaration := 'import' ImportDeclarationBody ';'
 

   ImportDeclarationBody := [ 'static' ] Identifier { '.' Identifier } [ '.' '*' ]
 

   InclusiveOrExpression :=
     ExclusiveOrExpression { '|' ExclusiveOrExpression }
 

   InterfaceBody := '{' {
     ';' |
     ModifiersOpt (
       'void' Identifier MethodDeclarationRest |
       'class' ClassDeclarationRest |
       'interface' InterfaceDeclarationRest |
       Type Identifier (
         MethodDeclarationRest |
         FieldDeclarationRest
       )
     )
   } '}'
 

   InterfaceDeclarationRest :=
     Identifier
     [ 'extends' ReferenceTypeList ]
     InterfaceBody
 

   LabeledStatement := Identifier ':' Statement
 

   LocalVariableDeclarators := VariableDeclarator { ',' VariableDeclarator }
 

   MethodBody := Block
 

   MethodDeclarationRest :=
     FormalParameters
     { '[' ']' }
     [ 'throws' ReferenceTypeList ]
     ( ';' | MethodBody )
 

   ModifiersOpt := { 'public' | 'protected' | 'private' | 'static' |
           'abstract' | 'final' | 'native' | 'synchronized' |
           'transient' | 'volatile' | 'strictfp'
 

   MultiplicativeExpression :=
     UnaryExpression { ( '*' | '/' | '%' ) UnaryExpression }
 

   PackageDeclaration := 'package' QualifiedIdentifier ';'
 

   PackageMemberTypeDeclaration :=
             ModifiersOpt 'class' ClassDeclarationRest |
             ModifiersOpt 'interface' InterfaceDeclarationRest
 

   Primary :=
     CastExpression |                        // CastExpression 15.16
     '(' Expression ')' |                    // ParenthesizedExpression 15.8.5
     Literal |                               // Literal 15.8.1
     Name |                                  // AmbiguousName
     Name Arguments |                        // MethodInvocation
     Name '[]' { '[]' } |                    // ArrayType 10.1
     Name '[]' { '[]' } '.' 'class' |        // ClassLiteral 15.8.2
     'this' |                                // This 15.8.3
     'this' Arguments |                      // Alternate constructor invocation 8.8.5.1
     'super' Arguments |                     // Unqualified superclass constructor invocation 8.8.5.1
     'super' '.' Identifier |                // SuperclassFieldAccess 15.11.2
     'super' '.' Identifier Arguments |      // SuperclassMethodInvocation 15.12.4.9
     NewClassInstance |
     NewAnonymousClassInstance |             // ClassInstanceCreationExpression 15.9
     NewArray |                              // ArrayCreationExpression 15.10
     NewInitializedArray |                   // ArrayInitializer 10.6
     BasicType { '[]' } |                    // Type
     BasicType { '[]' } '.' 'class' |        // ClassLiteral 15.8.2
     'void' '.' 'class'                      // ClassLiteral 15.8.2

   CastExpression :=
     '(' PrimitiveType { '[]' } ')' UnaryExpression |
     '(' Expression ')' UnaryExpression
 
   NewClassInstance := 'new' ReferenceType Arguments
 
   NewAnonymousClassInstance := 'new' ReferenceType Arguments [ ClassBody ]
 
   NewArray := 'new' Type DimExprs { '[]' }
 
   NewInitializedArray := 'new' ArrayType ArrayInitializer
 

   ReferenceType := QualifiedIdentifier
 

   ReferenceTypeList := ReferenceType { ',' ReferenceType }
 

   RelationalExpression :=
     ShiftExpression {
       ( ( '<' | '>' | '<=' | '>=' ) ShiftExpression ) |
       ( 'instanceof' ReferenceType )
     }
 

   ReturnStatement := 'return' [ Expression ] ';'
 

   Selector :=
     '.' Identifier |                       // FieldAccess 15.11.1
     '.' Identifier Arguments |             // MethodInvocation
     '.' 'this'                             // QualifiedThis 15.8.4
     '.' 'super' Arguments                  // Qualified superclass constructor invocation (JLS 8.8.5.1)
     '.' 'super' '.' Identifier |           // SuperclassFieldReference (JLS 15.11.2)
     '.' 'super' '.' Identifier Arguments | // SuperclassMethodInvocation (JLS 15.12.4.9)
     '.' 'new' Identifier Arguments [ ClassBody ] | // QualifiedClassInstanceCreationExpression  15.9
     '.' 'class'
     '[' Expression ']'                     // ArrayAccessExpression 15.13
 

   ShiftExpression :=
     AdditiveExpression { ( '<<' | '>>' | '>>>' ) AdditiveExpression }
 

   Statement :=
     LabeledStatement |
     Block |
     IfStatement |
     ForStatement |
     WhileStatement |
     DoStatement |
     TryStatement |
     'switch' ... |
     'synchronized' ... |
     ReturnStatement |
     ThrowStatement |
     BreakStatement |
     ContinueStatement |
     EmptyStatement |
     ExpressionStatement
 

   SwitchStatement :=
     'switch' '(' Expression ')' '{' { SwitchLabels BlockStatements } '}'

   SwitchLabels := SwitchLabels { SwitchLabels }

   SwitchLabel := 'case' Expression ':' | 'default' ':'
 

   SynchronizedStatement :=
     'synchronized' '(' expression ')' Block
 

   ThrowStatement := 'throw' Expression ';'
 

   TryStatement :=
     'try' Block Catches [ Finally ] |
     'try' Block Finally

   Catches := CatchClause { CatchClause }

   CatchClause := 'catch' '(' FormalParameter ')' Block

   Finally := 'finally' Block
 

   Type := (
     'byte' | 'short' | 'char' | 'int' | 'long' |
     'float' | 'double' | 'boolean' |
     ReferenceType
   ) { '[' ']' }
 

   UnaryExpression :=
     { PrefixOperator } Primary { Selector } { PostfixOperator }

   PrefixOperator := '++' | '--' | '+' | '-' | '~' | '!'

   PostfixOperator := '++' | '--'
 

   VariableDeclarator := Identifier VariableDeclaratorRest
 

   VariableDeclaratorRest := { '[' ']' } [ '=' VariableInitializer ]
 

   VariableInitializer :=
     ArrayInitializer |
     Expression
 

   WhileStatement := 'while' '(' Expression ')' Statement
 

Notice that there is no Parser.setErrorHandler() method, but parse errors always throw a ParseException. The reason being is that there is no reasonable way to recover from parse errors and continue parsing, so there is no need to install a custom parse error handler.

Parameters: optionalWarningHandler null to indicate that no warnings be issued