All Categories : Java

Appendix A

Java Languague Summary

by Laura Lemay and Michael Morrison

---

CONTENTS

• Reserved Words
• Literals
• Variable Declaration
• Variable Assignment
• Operators
• Objects
• Arrays
• Loops and Conditionals
• Class Definitions
• Method and Constructor Definitions
• Importing
• Guarding

---

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

Note

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 (http://java.sun.com) 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:

abstract	do	import	public	try
boolean	double	instanceof	return	void
break	else	int	short	volatile
byte	extends	interface	static	while
case	final	long	super
catch	finally	native	switch
char	float	new	synchronized
class	for	null	this
const	goto	package	throw
continue	if	private	throws
default	implements	protected	transient

Comments

/* this is the format of a multiline comment */
// 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	Integer (pick one type)
[ float | double ] varname	Float (pick one type)
char varname	Character
boolean varname	Boolean
classname varname	Class type
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) {     case value : statements     case value : statements     ...     default : statement}	switch (only with int or  char types)
for (initializer; test; change ) block	for loop
while ( test ) block	while loop
do block while (test)	do loop
break [ label ]	Break from loop or switch
continue [ label ]	Continue loop
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

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

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 [ catch ( exception ) block ] finally block	Same as previous example (can use optional catch or finally but not both)

---

---

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.