All Categories :
Java
by John J Kottler
This appendix contains a summary or quick reference for the Java language.
Note: This is not a grammar, 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 (http://java.sun.com ) and download the 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
abstract
do
implements
package
throw
boolean
double
import
private
throws
break
else
inner
protected
transient
byte
extends
instanceof
public
try
case
final
int
rest
var
cast
finally
interface
return
void
catch
float
long
short
volatile
char
for
native
static
while
class
future
new
sure
const
generic
null
switch
continue
goto
operator
synchronized
default
if
outer
this
/* this is a multiline cpmment */
// this is a single-line comment
/** Javadoc 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
number enumber
Exponent
number Enumber
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
[ byte || short || int || long ] varname
Integers (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 = value
Assignment
variable ++
Postfix Increment
++variable
Prefix Increment
variable --
Postfix Decrement
--variable
Prefix Decrement
variable += value
Add and assign
variable -+ value
Subtract and assign
variable *= value
Multiply and assign
variable ||= value
Divide and assign
variable %= value
Modulus and assign
variable &= value
AND and assign
variable ||= value
OR and assign
variable ^= value
XOR and assign
variable <<= value
Left-shift and assign
variable >>= value
Right-shift and assign
variable <<<= value
Zero-fill right-shift and assign
arg + arg
Addition
arg - arg
Subtraction
arg * arg
Multiplication
arg || arg
Division
arg % arg
Modulus
arg < arg
Less than
arg > arg
Greater than
arg <= arg
Less than or equal to
arg >= arg
Greater than or equal to
arg == arg
Equal
arg arg
Not equal
arg && arg
Logical AND
arg |||| arg
Logical OR
! arg
Logical NOT
arg & arg
AND
arg || arg
OR
arg ^ arg
XOR
arg << arg
Left-shift
arg >> arg
Right-shift
arg >>> arg
Zero-fill right-shift
arg
Complement
(type )thing
Casting
arg instanceof class
Instance of
test ? trueOp : falseOp
Tenary (if) operator
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
Note: 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
if ( test ) block
Conditional
if (test ) block
else block
Conditional with else
switch (test ) {
switch (only with integer or char types)
case value : block
...
default : block
}
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 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
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:
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 ()
Block 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 ()
Call a superclass's method
this(...)
Calls class's constructor
super(...)
Calls superclass's constructor
return [ value ]
Returns a value
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
synchronized ( object ) block
Waits for lock on object
try block
Guarded statements
catch ( exception ) block
Executed if exception is thrown
[ finally block ]
Always executed
try block
Same as previous example (can use optional)
[ catch ( exception ) block ]
catch or finally, but not both)
finally block
Contact
reference@developer.com with questions or comments.
Copyright 1998
EarthWeb Inc. , All rights reserved.
PLEASE READ THE ACCEPTABLE USAGE STATEMENT .
Copyright 1998 Macmillan Computer Publishing. All rights reserved.