Skip to main content.

Web Based Programming Tutorials

Homepage | Forum - Join the forum to discuss anything related to programming! | Programming Resources

Java Unleashed

Java Unleashed---Appendix A Previous Page toc Index Next Page

Appendix A

Java Language Summary

This appendix contains a summary or quick reference for the Java language, as described in this book.

This is not a grammar overview, nor is it a technical overview of the language itself. It’s a quick reference to be used after you already know the basics of how the language works. If you need a technical description of the language, your best bet is to visit the Java Web site ( and download the actual specification, which includes a full BNF grammar.

Language keywords and symbols are shown in a monospace font. Arguments and other parts to be substituted are in italic monospace.

Optional parts are indicated by brackets (except in the array syntax section). If there are several options that are mutually exclusive, they are shown separated by pipes (|) like this:

[ public | private | protected ] type varname

Reserved Words

The following words are reserved for use by the Java language itself (some of them are reserved but not currently used). You cannot use these terms to refer to classes, methods, or variable names:

charclassconstcontinuedefault do
double else extends final finally float
for goto ifimplements import instanceof
int interface long native new null
package privateprotected public return short
static super switchsynchronized this throw
throws transient try void volatile while


/* this is the format of a multiline comment */

// this is a single-line comment


number Type int
number[l | L] Type long
0xhex Hex integer
0Xhex Hex integer
0octal Octal integer
[ number ].number Type double
number[ f | f] Type float
number[ d | D] Type double
[ + | - ] number Signed
numberenumber Exponent
numberEnumber Exponent
‘character’ Single character
“characters” String
“” Empty string
\b Backspace
\t Tab
\n Line feed
\f Form feed
\r Carriage return
\” Double quote
\’ Single quote
\\ Backslash
\uNNNN Unicode escape (NNNN is hex)
true Boolean
false Boolean

Variable Declaration

[ byte | short | int | long ] varname       Integer (pick one type)

[ float | double ] varname                 Floats (pick one type)

char varname                                Characters

boolean varname                          Boolean

classname varname                           Class types

type varname, varname, varname              Multiple variables

The following options are available only for class and instance variables. Any of these options can be used with a variable declaration:

[ static ] variableDeclaration                            Class variable

[ final ] variableDeclaration                             Constants

[ public | private | protected ]  variableDeclaration     Access control

Variable Assignment

variable = value Assignment   variable &= value AND and assign
variable++ Postfix Incrementvariable | = value OR and assign
++variable Prefix Incrementvariable ^= value XOR and assign
variable–– Postfix Decrementvariable <<= value Left-shift and assign
––variable Prefix Decrementvariable >>= value Right-shift and assign
variable += value Add and assignvariable <<<= value Zero-fill right-shift and assign
variable –= value Subtract and assign
variable *= value Multiply and assign
variable /= value Divide and assign
variable %= value Modulus and assign


arg + arg Addition    arg && arg Logical AND    (type)thing Casting
arg – arg Subtractionarg || arg Logical ORarg instanceof class Instance of
arg * arg Multiplication! arg Logical NOTtest ? trueOp : falseOp Tenary (if) operator
arg / arg Divisionarg & arg AND
arg % arg Modulusarg | arg OR
arg < arg Less thanarg ^ arg XOR
arg > arg Greater thanarg << arg Left-shift
arg <= arg Less than or equal toarg >> arg Right-shift
arg >= arg Greater than or equal toarg >>> arg Zero-fill right-shift
arg == arg Equal~ arg Complement
arg != arg Not equal


new class(); Create new instance
new class(arg,arg,arg...) New instance with parameters
object.variable Instance variable
object.classvar Class variable
Class.classvar Class variable
object.method() Instance method (no args)
object.method(arg,arg,arg...) Instance method
object.classmethod() Class method (no args)
object.classmethod(arg,arg,arg...) Class method
Class.classmethod() Class method (no args)
Class.classmethod (arg,arg,arg...)Class method


The brackets in this section are parts of the array creation or access statements. They do not denote optional parts as they do in other parts of this appendix.

type varname[]                Array variable

type[] varname                Array variable

new type[numElements]         New array object

array[index]                  Element access

array.length                  Length of array

Loops and Conditionals

if ( test) block                                                Conditional

if ( test ) bloc

else block                                        Conditional with else


switch (test) {                                       switch (only with integer or char 

    case value : statements                               types)

    case value : statements


    default : statement


for (initializer; test; change ) block               for loop

while ( test ) block                                 while loop

do block                                               do loop

while (test)

break [ label ]                                     break from loop or switch

continue [ label ]                                 continue loops

label:                                              Labeled loops

Class Definitions

class classname block Simple Class definition
Any of the following optional modifiers can be added to the class definition:
[ final ] class classname block No subclasses
[ abstract ] class classname block Cannot be instantiated
[ public ] class classname block Accessible outside package
class classname [ extends Superclass ] block Define superclass
class classname [ implements interfaces ] block Implement one or more interfaces

Method and Constructor Definitions

The basic method looks like this, where returnType is a type name, a class name, or void.

returnType methodName() block                                              Basic method

returnType methodName (parameter, parameter, ...) block       Method with parameters 

Method parameters look like this:

type parameterName

Method variations can include any of the following optional keywords:

[ abstract ] returnType methodName () block                 Abstract method

 [ static ] returnType methodName() block                    Class method

[ native ] returnType methodName() block                   Native method

[ final ] returnType methodName() block                      final method

[ synchronized ] returnType methodName() block        Thread lock before executing

[ public | private | protected ] returnType methodName ()             Access control

Constructors look like this:

classname() block                                                           Basic constructor

classname(parameter, parameter, parameter...) block     Constructor with parameters

[ public | private | protected] classname() block              Access control   

                                                        In the method/constructor body you can use these references and methods:

this                                                 Refers to current object

super                                              Refers to superclass

super.methodName()                           Calls a superclass’s method

this(...)                                            Calls class’s constructor

super(...)                                         Calls superclass’s constructor

return [ value ]                                        Returns a value

Packages, Interfaces, and Importing

import package.className Imports specific class name
import package.* Imports all classes in package
package packagename Classes in this file belong to this package

interface interfaceName [ extends anotherInterface ] block

[ public ] interface interfaceName block

[ abstract ] interface interfaceName block

Exceptions and Guarding

synchronized ( object ) block Waits for lock on object
try block Guarded statements
catch ( exception ) block Executed if exception is throw
[ finally block ] Always executed
try block Same as previous example (can
[ catch ( exception ) block ] use optional catch or finally,
finally block but not both)

Previous Page toc Index Next Page