Skip to main content.

Web Based Programming Tutorials

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

Teach Yourself Web Publishing with HTML 3.2 in 14 Days

Appendix G -- Java Language Reference

Appendix G

Java Language Reference


From Sun Microsystems comes Java, the platform-independent programming language for creating executable content within Web pages. Based on C++, this is a fully fledged programming language and, as such, should not be taken lightly. When mastered, Java could prove as limitless as the programmer's imagination. Indeed, some have even gone so far as to predict that the computer software industry is seriously under threat because in a few years, all applications will be in the form of applets, downloaded as and when they are required.

Recent versions of Netscape (since version 2.0) have added the capability to support executable content, previously possible only using the actual HotJava browser developed by Sun MicroSystems. You can include live audio, animation, or applications to your Web pages in the form of Java applets. The applets are pre-compiled and included in HTML documents.

The information provided here describes only the necessary HTML elements that allow pre-compiled Java applets to be added to your HTML documents. It does not describe how to actually write Java applets. Such information is well beyond the scope of this appendix. For more information about writing Java code, see Teach Yourself Java in 21 Days (also from Publishing); to obtain a copy of the Java development kit:

This appendix provides an overview of how you can include Java applets in your pages, a Java language reference, and a desciption of the components of the Java Class Library.

<APPLET>: Including a Java Applet

Internet Explorer supports the inclusion of Java applets using the <OBJECT> object-insertion mechanism.

To add an applet to an HTML page, you need to use the <APPLET> HTML element. For example,

<APPLET CODE="Applet.class" WIDTH=200 HEIGHT=150>

This tells the viewer or browser to load the applet whose compiled code is in Applet.class (in the same directory as the current HTML document), and to set the initial size of the applet to 200 pixels wide and 150 pixels high. (The <APPLET> element supports standard image type attributes, explained later in this appendix.)

Here is a more complex example of an <APPLET> element:

CODE="NervousText.class" width=400 height=75 align=center >
<PARAM NAME="text" VALUE="This is the Applet Viewer.">
If you were using a Java-enabled browser, you would see dancing text
instead of this paragraph.

This tells the viewer or browser to do the following:

The viewer/browser must also set the applet's "text" attribute (which customizes the text this applet displays) to be "This is the Applet Viewer." If the page is viewed by a browser that can't execute applets written in Java, the browser ignores the <APPLET> and <PARAM> elements, displaying the HTML between the <BLOCKQUOTE> and </BLOCKQUOTE> elements.

The complete syntax for the <APPLET> element example is as follows :

CODE = appletFile
[ALT = alternateText]
[NAME = appletInstanceName]
WIDTH = pixels HEIGHT = pixels
[ALIGN = alignment]
[VSPACE = pixels] [HSPACE = pixels]
[<PARAM NAME = appletAttribute1 VALUE = value>]
[<PARAM NAME = appletAttribute2 VALUE = value>]
. . .

Each of the <APPLET> attributes are presented in alphabetical order and discussed briefly in the following sections.

ALIGN = alignment

This required attribute specifies the alignment of the applet. The possible values of this attribute are the same as those for the IMG element: left, right, top, texttop, middle, absmiddle, baseline, bottom, absbottom.

ALT = alternateText

This optional attribute specifies any text that should be displayed if the browser understands the <APPLET> element but can't run applets written in the Java Programming Language.

CODE = appletFile

This required attribute gives the name of the file that contains the applet's compiled Applet subclass. This file is relative to the base URL of the applet. It cannot be absolute.


This optional attribute specifies the base URL of the applet-the directory that contains the applet's code. If this attribute is not specified, then the document's URL is used.

NAME = appletInstanceName

This optional attribute specifies a name for the applet instance, which makes it possible for applets on the same page to find (and communicate with) each other.

<PARAM NAME = appletAttribute1 VALUE = value>

This element is the only way to specify an applet-specific attribute. Applets access their attributes with the getParameter() method.

WIDTH = pixels HEIGHT = pixels

These required attributes give the initial width and height (in pixels) of the applet display area, not counting any windows or dialogs that the applet brings up.

VSPACE = pixels HSPACE = pixels

These option attributes specify the number of pixels above and below the applet (VSPACE) and on each side of the applet (HSPACE). They're treated the same way as the IMG element's VSPACE and HSPACE attributes.

<EMBED>: Embedding Objects

The <EMBED> element allows authors to embed objects directly into an HTML page.

The basic syntax is as follows:


Here, "_URL_" represents the URL of the object that is to be embedded.

The <EMBED> element comes into its own when used to embed objects that will be handled by plug-in modules. Plug-in modules are supported by Netscape. These are essentially dynamic code modules that extend the capabilities of the browser by providing code that can handle data types for which Netscape has no internal handling functions. When Netscape encounters some data it cannot handle embedded into the HTML document (via use of the <EMBED> element), it will search for a plug-in module that can handle that data type and load it, enabling the viewing/transforming (and any other modifications possible) of the object.

Netscape version 3.0 and above ("Atlas") comes with three standard plug-in modules. These handle in-line sound, video, and VRML. Possible attributes are plug-in-dependent, and you can consult the Netscape documentation of the plug-in module you may want to use to include objects.

The Sound Plug-in

The Sound plug-in that Netscape installs can be used to embed .WAV, .MID, .AU, and .AIFF sound files. Where the sound file is embedded, a simple control panel is displayed, giving the user Play, Stop, Pause, and Volume controls. The display of the embedded control unit can take standard <IMG> attributes (ALIGN, HEIGHT, WIDTH, HSPACE, VSPACE, and BORDER).

The plug-in also accepts the additional attributes (listed in the following sections) with this syntax:

<EMBED SRC="filename.ext">

Here, .ext is .MID, .WAV, and so on, specific to the sound plug-in.


By default, the controls unit for playing the embedded sound file is displayed and the sound file is only played when the user clicks the Play button. This overrides the wait and will play the sound file as soon as it is finished loading.


This sets the initial volume for the playback of the sound file. It accepts a numerical value, which is a percentage of the total volume possible. The default for this is 50 percent. The volume can also be controlled by using the volume lever on the control unit displayed.

The Video Plug-in

This plug-in allows the embedding of .AVI video clips. The display of the embedded viewing window can accept standard <IMG> attributes (ALIGN, HEIGHT, WIDTH, HSPACE, VSPACE and BORDER).

The video plug-in accepts the following attributes (listed in the following sections) with this syntax:

<EMBED SRC="filename.avi">


By default, the window for playing the embedded video clip is displayed and the video clip is only played when the user clicks the display window. This over-rides the wait and will play the video clip as soon as it is finished loading.


This allows the video clip to play on a continuous loop once activated. By default (unless the AUTOSTART attribute is set), the video clip will begin to play after being clicked on. (A right mouse click will bring up a control menu.)

Live3D (The VRML Plug-in)

This plug-in allows the embedding of VRML worlds (.WRL) into an HTML document. The display of the embedded VRML world can accept standard <IMG> attributes (ALIGN, HEIGHT, WIDTH, HSPACE, VSPACE and BORDER). For any embedded VRML world, various display and setup options are accessible via a controls menu displayed by right-clicking on the embedded world. The basic syntax is as follows:

<EMBED SRC="filename.wrl">

Quick Reference

This section provides a quick reference for the Java language, by language feature.

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 ( 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 for 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 doubleint static
boolean elseinterface super
break extendslong switch
byte finalnative synchronized
case finallynew this
catch floatnull throw
char forpackage throws
class gotoprivate transient
const ifprotected try
continue implements publicvoid
default importreturn volatile
do instanceofshort while


The following are valid comments in Java:

/* this is a multiline comment */
// 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
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


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


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 integer 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 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 [vb] private [vb] 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 ] try block [ catch ( exception ) block ]finally block Always executed Same as previous example (can use optional catch or finally, but not both)

The Java Class Library

This rest of this appendix provides a general overview of the classes available in the standard Java packages (that is, the classes that are guaranteed to be available in any Java implementation). This information is intended for general reference; for more specific information about each class (its inheritance, variables, and methods), as well as the various exceptions for each package, see the API documentation from Sun at


The java.lang package contains the classes and interfaces that make up the core Java language.


Cloneable Interface indicating that an object may be copied or cloned
Runnable Methods for runnable objects (for example, applets that include threads)


Boolean Object wrapper for boolean values
Character Object wrapper for char values
Class Run-time representations of classes
ClassLoader Abstract behavior for handling loading of classes
Compiler System class that gives access to the Java Compiler
Double Object wrapper for double values
Float Object wrapper for float values
Integer Object wrapper for int values
Long Object wrapper for long values
Math Utility class for math operations
Number Superclass of all number classes (Integer, Float, and so on)
Object Generic Object class, at top of inheritance hierarchy
Process Processes such as those spawned using methods in the System class
Runtime The Java runtime
SecurityManager Abstract behavior for implementing security policies
String Character strings
StringBuffer Mutable strings
System System-based behavior, provided in a platform-independent way
Thread Methods for managing threads and classes that run in threads
ThreadDeath Class of object thrown when a thread is asynchronously terminated
ThreadGroup A group of threads
Throwable A superclass for errors and exceptions
UNIXProcess UNIX-specific processes
Win32Process Windows-specific processes


The java.util package contains various utility classes and interfaces, including random numbers, system properties, and other useful utility classes.


Enumeration Methods for enumerating sets of values
Observer Methods for enabling classes to be observable by Observable objects


BitSet A set of bits
Date The current system date, as well as methods for generating and parsing dates
Dictionary An abstract class that maps between keys and values (superclass of HashTable)
Hashtable A hash table
Observable An abstract class for observable objects
Properties A hashtable that contains behavior for setting and retrieving persistent properties of the system or of a class
Random Utilities for generating random numbers
Stack A stack (a last-in-first-out queue)
StringTokenizer Utilities for splitting strings into individual "tokens"
Vector A growable array, similar to a linked list

The package provides input and output classes and interfaces for streams and files.


DataInput Methods for reading machine-independent input streams
DataOutput Methods for writing machine-independent output streams
FilenameFilter Methods for filtering filenames


BufferedInputStream A buffered input stream
BufferedOutputStream A buffered output stream
ByteArrayInputStream A byte array buffer for an input stream
ByteArrayOutputStream A byte array buffer for an output stream
DataInputStream Enables you to read primitive Java types (ints, chars, booleans, and so on) from a stream in a machine-independent way
DataOutputStream Enables you to write primitive Java data types (ints, chars, booleans, and so on) to a stream in a machine-independent way
File Represents a file on the host's file system
FileDescriptor Holds onto the UNIX-like file descriptor of a file or socket
FileInputStream An input stream from a file, constructed using a filename or descriptor
FileOutputStream An output stream to a file, constructed using a filename or descriptor
FilterInputStream Abstract class which provides a filter for input streams (and for adding stream functionality such as buffers)
FilterOutputStream Abstract class which provides a filter for output streams (and for adding stream functionality such as buffers
InputStream An abstract class presenting an input stream of bytes; the parent of all input streams in this package
LineNumberInputStream An input stream that keeps track of line numbers
OutputStream An abstract class representing an output stream of bytes; the parent of all output streams in this package
PipedInputStream A piped input stream, which should be connected to a PipedOutputStream to be useful
PipedOutputStream A piped output stream, which should be connected to a PipedInputStream to be useful
PrintStream An output stream for printing (used by System.out.printin(...))
PushbackInputStream An input stream with a 1-byte push-back buffer
RandomAccessFile A random-access input and output file that can be constructed from filenames, descriptors, or objects
SequenceInputStream Converts a sequence of input streams into a single input steam
StreamTokenizer Converts an input stream into a series of individual tokens
StringBufferInputStream Use a string buffer as an input stream to a String object

The package contains classes and interfaces for performing network operations, such as sockets and URLs.


ContentHandlerFactory Methods for creating ContentHandler objects
SocketImplFactory Methods for creating socket implementations (instance of the SocketImpl class)
URLStreamHandlerFactory Methods for creating URLStreamHandler objects


ContentHandler A class that can read data from a URL connection and construct the appropriate local object, based on mime types
DatagramPacket A datagram packet (UDP)
DatagramSocket A datagram socket
InetAddress An object representation of an Internet host (host name, IP address)
ServerSocket An abstract server-side socket
Socket An abstract socket
SocketImpl An abstract class for specific socket implementations
URL An object representation of a URL
URLConnection A socket that can handle various Web-based protocols (http, ftp, and so on)
URLEncoder Turns strings into x-www-form-urlencoded format
URLStreamHandler Abstract class for managing streams to object references by URLs


The java.awt package contains the classes and interfaces that make up the Abstract Windowing Toolkit.


LayoutManager Methods for laying out containers
MenuContainer Methods for menu-related containers


BorderLayout A layout manager for arranging items in border formation
Button A UI pushbutton
Canvas A canvas for drawing and performing other graphics operations
CardLayout A layout manager for HyperCard-like metaphors
Checkbox A checkbox
CheckboxGroup A group of exclusive checkboxes (radio buttons)
CheckboxMenuItem A toggle menu item
Choice A popup menu of choices
Color An abstract representation of a color
Component The generic class for all UI components
Container A component that can hold other components or containers
Dialog A window for brief interactions with users
Dimension An object representing width and height
Event An class representing events called by the system or generated by user input
FileDialog A dialog for getting file names from the local file system
FlowLayout A layout manager that lays out objects from left to right in rows
Font An abstract representation of a font
FontMetrics Information about a specific font's character shapes and height and width information
Frame A top-level window with a title
Graphics A representation of a graphics context and methods to draw and paint shapes and objects
GridBagConstraints Constraints for components laid out using GridBagLayout
GridBagLayout A layout manager that aligns components horizontally and vertically based on their values from GridBagConstraints
GridLayout A layout manager with rows and columns; elements are added to each cell in the grid
Image An abstract representation of a bitmap image
Insets Distances from the outer border of the window to lay out components
Label A text label for UI components
List A scrolling list
MediaTracker A way to keep track of the status of media objects being loaded over the Net
Menu A menu, which can contain menu items and is a container on a menubar
MenuBar A menubar (container for menus)
MenuComponent The superclass of all menu elements
MenuItem An individual menu item
Panel A container that is displayed
Point An object representing a point (x and y coordinates)
Polygon An object representing a set of points
Rectangle An object representing a rectangle (x and y coordinates for the top corner, plus width and height)
Scrollbar A UI scrollbar object
TextArea A multiline, scrollable, editable text field
TextComponent The superclass of all editable text components
TextField A fixed-size editable text field
Toolkit Binds the abstract AWT classes to a platform-specific toolkit implementation
Window A top-level window, and the superclass of the Frame and Dialog classes


The java.awt.image package is a subpackage of the AWT that provides classes for managing bitmap images.


ImageConsumer Methods for receiving image data filters through an ImageProducer
ImageObserver Methods to keep track of the loading and construction of an image
ImageProducer Methods for producing image data received by an ImageConsumer


ColorModel A class for managing color information for images
CropImageFilter A filter for cropping images to a particular size
DirectColorModel A specific color model for managing and translating pixel color values
FilteredImageSource An ImageProducer that takes an image and an ImageFilter object and produces an image for an ImageConsumer
ImageFilter A filter that takes image data from an ImageProducer, modifies it in some way, and hands it off to a ImageConsumer
IndexColorModel A specific color model for managing and translating color values in a fixed-color map
MemoryImageSource An image producer that gets its image from memory; used after constructing an image by hand
PixelGrabber An ImageConsumer that retrieves a subset of the pixels in an image
RGBImageFilter A filter for modifying the RBG values of pixels in RGB images


The java.awt.peer package is a subpackage of AWT that contains abstract classes to link AWT to the code to display platform-specific interfaces elements (for example, Motif, Macintosh, Windows 95).


ButtonPeer Peer for the Button class
CanvasPeer Peer for the Canvas class
CheckboxMenuItemPeer Peer for the CheckboxMenuItem class
CheckboxPeer Peer for the Checkbox class
ChoicePeer Peer for the Choice class
ComponentPeer Peer for the Component class
ContainerPeer Peer for the Container class
DialogPeer Peer for the Dialog class


The java.applet package provides applet-specific behavior.


AppletContext Methods to refer to the applet's context
AppletStub Methods for implementing applet viewers
AudioClip Methods for playing audio files


Applet The base applet class