Previous Page TOC Next Page


— Appendix B —
JavaScript and Java Language Reference

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

Reserved Words

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


Comments 

/* this is a multiline cpmment */

// this is a single-line comment

/** Javadoc comment */

Literals

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

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 Assignment

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

Operators

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

Objects

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

Arrays

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

Loops and Conditionals

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 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 parameter

Name

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

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 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

Previous Page TOC Next Page