Laura Lemay's Teach Yourself Web Pub. W/HTML 3.2 twpxg.htm

- — Appendix G —Java Language Reference

- <APPLET>: Including a Java Applet

- ALIGN = alignment
- ALT = alternateText
- CODE = appletFile
- CODEBASE = URL
- NAME = appletInstanceName
- <PARAM NAME = appletAttribute1 VALUE = value>
- WIDTH = pixels HEIGHT = pixels
- VSPACE = pixels HSPACE = pixels

- <EMBED> Embedding Objects

- The Sound Plug-in

- AUTOSTART="true"
- VOLUME="value"

- The Video Plug-in

- AUTOSTART="true"
- LOOP="true"

- Live3D (The VRML Plug-in)

- Quick Reference

- Reserved Words
- Comments
- Literals
- Variable Declaration
- Variable Assignment
- Operators
- Objects
- Arrays
- Loops and Conditionals
- Class Definitions
- Method and Constructor Definitions
- Packages, Interfaces, and Importing
- Exceptions and Guarding

- The Java Class Library

- java.lang
- Interfaces
- Classes

- java.util

- Interfaces
- Classes
- java.io
- Interfaces
- Classes

- java.net

- Interfaces
- Classes

- java.awt

- Interfaces
- Classes

- java.awt.image

- Interfaces
- Classes

- java.awt.peer

- Interfaces

- java.applet

- Interfaces
- Classes

#
— 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 Sams.net Publishing); to obtain a copy of the Java development kit:
http://java.sun.com/

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>

    </APPLET>

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:

    <APPLET CODEBASE="http://java.sun.com/JDK-prebeta1/applets/NervousText"

     CODE="NervousText.class" width=400 height=75 align=center >

    <PARAM NAME="text" VALUE="This is the Applet Viewer.">

    <BLOCKQUOTE>

    <HR>

    If you were using a Java-enabled browser, you would see dancing text

    instead of this paragraph.

    <HR>

    </BLOCKQUOTE>

    </APPLET>

This tells the viewer or browser to do the following:

- Load the applet whose compiled code is at the URL http://java.sun.com/JDK-prebeta1/applets/NervousText/NervousText.class.
- Set the initial size of the applet to 400¥75 pixels.
- Align the applet in the center of the line.

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:

    <APPLET

    [CODEBASE = URL]

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

    . . .

    [alternateHTML]

    </APPLET>

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.

####
CODEBASE = URL

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:

    <EMBED SRC="_URL_">

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.

#####
AUTOSTART="true"

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.

#####
VOLUME="value"

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

#####
AUTOSTART="true"

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.

#####
LOOP="true"

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

####
Comments

The following are valid comments in Java:

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

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 | Conditional with else
else block |
switch (test) { | switch (only with integer or char types)
case value : statements | 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 [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 ] | Always executed
try block | Same as previous example (can
[ catch ( exception ) block ] | use optional catch or finally,
finally block | 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 http://java.sun.com.

#####
java.lang

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

#####
Interfaces

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

#####
Classes

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

####
java.util

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

#####
Interfaces

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

#####
Classes

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

#####
java.io

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

#####
Interfaces

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

#####
Classes

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

####
java.net

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

#####
Interfaces

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

#####
Classes

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

####
java.awt

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

#####
Interfaces

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

#####
Classes

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

####
java.awt.image

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

#####
Interfaces

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

#####
Classes

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

####
java.awt.peer

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

#####
Interfaces

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

####
java.applet

The java.applet package provides applet-specific behavior.

#####
Interfaces

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

#####
Classes

Applet | The base applet class