AbstractMethodError;Thrown when an application
tries to call an
abstract method. Normally, this
error is caught by
the compile this error
can only occur at
run time if the
definition of some class
has incompatibly changed since
the currently executing method
was last compiled.;
AccessException;Create a new AccessException
with a description.;
Acl;Interface representing an Access
Control List (ACL). An
Access Control List is
a data structure used
to guard access to
resources. An ACL can
be thought of as
a data structure with
multiple ACL entries. Each
ACL entry, of interface
type AclEntry, contains a
set of permissions associated
with a particular principal.
(A principal represents an
entity such as an
individual user or a
group). Additionally, each ACL
entry is specified as
being either positive or
negative. If positive, the
permissions are to be
granted to the associated
principal. If negative, the
permissions are to be
denied. The ACL Entries
in each ACL observe
the following rules: Each
principal can have at
most one positive ACL
entry and one negative
entr that is, multiple
positive or negative ACL
entries are not allowed
for any principal. Each
entry specifies the set
of permissions that are
to be granted (if
positive) or denied (if
negative). If there is
no entry for a
particular principal, then the
principal is considered to
have a null (empty)
permission set. If there
is a positive entry
that grants a principal
a particular permission, and
a negative entry that
denies the principal the
same permission, the result
is as though the
permission was never granted
or denied. Individual permissions
always override permissions of
the group(s) to which
the individual belongs. That
is, individual negative
permissions (specific denial
of permissions) override the
groups' positive permissions.
And individual positive
permissions override the groups'
negative permissions. The
java.security.acl
package provides the interfaces
to the ACL and
related data structures (ACL
entries, groups, permissions,
etc.), and the sun.security.acl
classes provide a default
implementation of the interfaces.
For example,
java.security.acl.Acl provides
the interface to an ACL and the
sun.security.acl.AclImpl class
provides the default
implementation
of the interface. The
java.security.acl.Acl
interface extends the
java.security.acl.Owner
interface. The Owner
interface is used to
maintain a list of
owners for each ACL.
Only owners are allowed
to modify an ACL.
For example, only an
owner can call the
ACL's addEntry method to
add a new ACL
entry to the ACL.
;
AclEntry;This is the interface
used for representing one
entry in an Access
Control List (ACL). An
ACL can be thought
of as a data
structure with multiple ACL
entry objects. Each ACL
entry object contains a
set of permissions associated
with a particular principal.
(A principal represents an
entity such as an
individual user or a
group). Additionally, each ACL
entry is specified as
being either positive or
negative. If positive, the
permissions are to be
granted to the associated
principal. If negative, the
permissions are to be
denied. Each principal can
have at most one
positive ACL entry and
one negative entr that
is, multiple positive or
negative ACL entries are
not allowed for any
principal. Note: ACL entries
are by default positive.
An entry becomes a
negative entry only if
the setNegativePermissions method
is called on it.;
AclNotFoundException;This is an exception
that is thrown whenever
a reference is made
to a non-existent ACL
(Access Control List).;
ActionEvent;The action semantic event.
;
ActionListener;The listener interface for
receiving action events.;
Adjustable;The interface for objects
which have an adjustable
numeric value contained within
a bounded range of
values.;
AdjustmentEvent;The adjustment event emitted
by Adjustable objects.;
AdjustmentListener;The listener interface for
receiving adjustment events.;
Adler32;A class that can
be used to compute
the Adler-32 checksum of
a data stream. An
Adler-32 checksum is almost
as reliable as a
CRC-32 but can be
computed much faster.;
AlreadyBoundException; ;
Applet;An applet is a
small program that is
intended not to be
run on its own,
but rather to be
embedded inside another
application.
The Applet class must
be the superclass of
any applet that is
to be embedded in
a Web page or
viewed by the Java
Applet Viewer. The Applet
class provides a standard
interface between applets and
their environment.;
AppletContext;This interface corresponds to
an applet's environment: the
document containing the applet
and the other applets
in the same document.
The methods in this
interface can be used
by an applet to
obtain information about its
environment.;
AppletStub;When an applet is
first created, an applet
stub is attached to
it using the applet's
setStub method. This stub
serves as the interface
between the applet and
the browser environment or
applet viewer environment in
which the application is
running.;
AreaAveragingScaleFilter;An ImageFilter class for
scaling images using a
simple area averaging algorithm
that produces smoother results
than the nearest neighbor
algorithm. This class extends
the basic ImageFilter Class
to scale an existing
image and provide a
source for a new
image containing the resampled
image. The pixels in
the source image are
blended to produce pixels
for an image of
the specified size. The
blending process is analogous
to scaling up the
source image to a
multiple of the destination
size using pixel replication
and then scaling it
back down to the
destination size by simply
averaging all the pixels
in the supersized image
that fall within a
given pixel of the
destination image. If the
data from the source
is not delivered in
TopDownLeftRight order then the
filter will back off
to a simple pixel
replication behavior and utilize
the requestTopDownLeftRightResend
() method to
refilter the pixels in
a better way at
the end. It is
meant to be used
in conjunction with a
FilteredImageSource object to
produce scaled versions of
existing images.;
ArithmeticException;Thrown when
an exceptional
arithmetic condition has occurred.
For example, an integer
"divide by zero" throws
an instance of this
class.;
Array;The Array class provides
static methods to dynamically
create and access Java
arrays. Array permits widening
conversions to occur during
a get or set
operation, but throws an
IllegalArgumentException if a narrowing
conversion would occur.;
ArrayIndexOutOfBoundsException;Thrown to indicate that
an array has been
accessed with an illegal
index. The index is
either negative or greater
than or equal to
the size of the
array.;
ArrayStoreException;Thrown to indicate that
an attempt has been
made to store the
wrong type of object
into an array of
objects.;
AudioClip;The AudioClip interface is
a simple abstraction for
playing a sound clip.
Multiple AudioClip items can
be playing at the
same time, and the
resulting sound is mixed
together to produce a
composite.;
AWTError;An AWT Error.;
AWTEvent;The root event class
for all AWT events.
This class and its
subclasses supercede the original
java.awt.Event class. Subclasses
of this root AWTEvent class
defined outside of the
java.awt.event package should
define event ID values greater
than the value defined
by RESERVED_ID_MAX. The event
masks defined in this
class are needed ONLY
by component subclasses which
are using Component.enableEvents() to
select for event types
not selected by registered
listeners. If a listener
is registered on a
component, the appropriate event
mask is already set
internally by the component.
;
AWTEventMulticaster;A class which implements
efficient multi-cast event dispatching
for the AWT events
defined in the java.awt.event
package. This class will
manage the structure of
a chain of event
listeners and dispatch events
to those listeners. An
example of how this
class could be used
to implement a new
component which fires "action"
events.
;
AWTException;Signals that an Absract
Window Toolkit exception has
occurred.;
BeanDescriptor;A BeanDescriptor provides global
information about a "bean",
including its Java class,
its displayName, etc. This
is one of the
kinds of descriptor returned
by a BeanInfo object,
which also returns descriptors
for properties, method, and
events.;
BeanInfo;A bean implementor who
wishes to provide explicit
information about their bean
may provide a BeanInfo
class that implements this
BeanInfo interface and provides
explicit information about the
methods, properties, events, etc,
of their bean. A
bean implementor doesn't need
to provide a complete
set of explicit information.
You can pick and
choose which information you
want to provide and
the rest will be
obtained by automatic analysis
using low-level reflection of
the bean classes' methods
and applying standard design
patterns. You get the
opportunity to provide lots
and lots of different
information as part of
the various XyZDescriptor classes.
But don't panic, you
only really need to
provide the minimal core
information required by the
various constructors. See also
the SimpleBeanInfo class which
provides a convenient "noop"
base class for BeanInfo
classes, which you can
override for those specific
places where you want
to return explicit info.
To learn about all
the behaviour of a
bean see the Introspector
class.;
Beans;This class provides some
general purpose beans control
methods.;
BigDecimal;Immutable, arbitrary-precision signed decimal
numbers. A BigDecimal consists
of an arbitrary precision
integer value and a
non-negative integer scale, which
represents the number of
decimal digits to the
right of the decimal
point. (The number represented
by the BigDecimal is
intVal/scale.) BigDecimals provide operations
for basic arithmetic, scale
manipulation, comparison, format
conversion and hashing. The
BigDecimal class gives its user
complete control over rounding
behavior, forcing the user
to explicitly specify a
rounding behavior for operations
capable of discarding precision
(divide and setScale). Eight
rounding modes are provided
for this purpose. Two
types of operations are
provided for manipulating the
scale of a BigDecimal:
scaling/rounding operations and
decimal point motion operations.
Scaling/Rounding
operations (SetScale) return a
BigDecimal whose value is
approximately (or exactly) equal
to that of the
operand, but whose scale
is the specified valu
that is, they increase
or decrease the precision
of the number with
minimal effect on its
value. Decimal point motion
operations (movePointLeft and
movePointRight)
return a BigDecimal created
from the operand by
moving the decimal point
a specified distance in
the specified directio that
is, they change a
number's value without affecting
its precision.;
BigInteger;Immutable arbitrary-
precision integers. All
operations behave as if
BigIntegers were represented in
two's-complement notation
(like Java's primitive integer
types). BigIntegers
provide analogues to all
of Java's primitive integer
operators, and all relevant
static methods from java.lang.Math.
Additionally, BigIntegers provide
operations for modular arithmetic,
GCD calculation, primality
testing, prime generation,
single-bit manipulation, and
a few other odds
and ends. Semantics of
arithmetic operations exactly
mimic those of java's integer
arithmetic operators, as defined
in The Java Language
Specification. For example,
division by zero throws an
ArithmeticException, and division
of a negative by a
positive yields a negative
(or zero) remainder. All
of the details in
the Spec concerning overflow
are ignored, as BigIntegers
are made as large
as necessary to accommodate
the results of an
operation. Semantics of shift
operations extend those of
Java's shift operators to
allow for negative shift
distances. A right-shift with
a negative shift distance
results in a left
shift, and vice-versa. The
unsigned right shift operator
(>>>) is omitted, as
this operation makes little
sense in combination with
the "infinite word size"
abstraction provided by this
class. Semantics of bitwise
logical operations are are
exactly mimic those of
Java's bitwise integer operators.
The Binary operators (and,
or, xor) implicitly perform
sign extension on the
shorter of the two
operands prior to performing
the operation. Comparison
operations perform signed integer
comparisons, analogous to those
performed by java's relational and
equality operators. Modular
arithmetic operations are provided to
compute residues, perform
exponentiation, and compute
multiplicative inverses.
These methods always return
a non-negative result, between
0 and (modulus -
1), inclusive. Single-bit
operations operate on a single
bit of the two's-complement
representation of their operand.
If necessary, the operand
is sign extended so
that it contains the
designated bit. None of
the single-bit operations can
produce a number with
a different sign from
the the BigInteger being
operated on, as they
affect only a single
bit, and the "infinite
word size" abstraction provided
by this class ensures
that there are infinitely
many "virtual sign bits"
preceding each BigInteger.;
BindException;Signals that an error
occurred while attempting to
bind a socket to
a local address and
port. Typically, the port
is in use, or
the requested local address
could not be assigned.
;
BitSet;A set of bits.
The set automatically grows
as more bits are
needed.;
Boolean;The Boolean class wraps
a value of the
primitive type boolean in
an object. An object
of type Boolean contains
a single field whose
type is boolean. In
addition, this class provides
many methods for converting
a boolean to a
String and a String
to a boolean, as
well as other constants
and methods useful when
dealing with a boolean.
;
BorderLayout;A TNT style border
bag layout. It will
layout a container using
members named "North", "South",
"East", "West" and "Center".
When you add a
component to a container
that has a BorderLayout
layout manager, be sure
to specify a string
for where to add
the component.The "North",
"South", "East",
and "West" components get
layed out according to
their preferred sizes and
the constraints of the
container's size. The "Center"
component will get any
space left over.;
BreakIterator;The BreakIterator class implements
methods for finding the
location of boundaries in
text. Instances of BreakIterator
maintain a current position
and scan over text
returning the index of
characters where boundaries occur.
Internally, BreakIterator scans
text using a CharacterIterator,
and is thus able to
scan text held by
any object implementing that
protocol. A
StringCharacterIterator is
used to scan Strings
passed to setText. Line
boundary analysis determines where
a text string can
be broken when line-wrapping.
The mechanism correctly handles
punctuation and hyphenated words.
Sentence boundary analysis allows
selection with correct
interpretation of periods within
numbers and abbreviations, and
trailing punctuation marks such as
quotation marks and parentheses.
Word boundary analysis is
used by search and
replace functions, as well
as within text editing
applications that allow the
user to select words
with a double click.
Word selection provides correct
interpretation of punctuation
marks within and following words.
Characters that are not
part of a word,
such as symbols or
punctuation marks, have word-
breaks on both sides. Character
boundary analysis allows users
to interact with characters
as they expect to,
for example, when moving
the cursor through a
text string. Character boundary
analysis provides correct
navigation of through character
strings, regardless of how the
character is stored. For
example, an accented character
might be stored as
a base character and
a diacritical mark. What
users consider to be
a character can differ
between languages. This is
the interface for all
text boundaries.;
BufferedInputStream;The class implements a
buffered input stream. By
setting up such an
input stream, an application
can read bytes from
a stream without necessarily
causing a call to
the underlying system for
each byte read. The
data is read by
blocks into a buffe
subsequent reads can access
the data directly from
the buffer.;
BufferedOutputStream;The class implements a
buffered output stream. By
setting up such an
output stream, an application
can write bytes to
the underlying output stream
without necessarily causing a
call to the underlying
system for each byte
written. The data is
written into a buffer,
and then written to
the underlying stream if
the buffer reaches its
capacity, the buffer output
stream is closed, or
the buffer output stream
is explicity flushed.;
BufferedReader;Read text from a
character-input stream, buffering
characters so as to provide
for the efficient reading
of characters, arrays, and
lines. The buffer size
may be specified, or
the default size may
be used. The default
is large enough for
most purposes. In general,
each read request made
of a Reader causes
a corresponding read request
to be made of
the underlying character or
byte stream. It is
therefore advisable to wrap
a BufferedReader around any
Reader whose read() operations
may be costly, such
as FileReaders and
InputStreamReaders.
For example, BufferedReader in
= new BufferedReader
(new FileReader("foo.in")
will buffer the input
from the specified file.
Without buffering, each invocation
of read() or readLine()
could cause bytes to
be read from the
file, converted into characters,
and then returned, which
can be very inefficient.
Programs that use DataInputStreams
for textual input can
be localized by replacing
each DataInputStream with an
appropriate BufferedReader.;
BufferedWriter;Write text to a
character-output stream, buffering
characters so as to provide
for the efficient writing
of single characters, arrays,
and strings. The buffer
size may be specified,
or the default size
may be accepted. The
default is large enough
for most purposes. A
newLine() method is provided,
which uses the platform's
own notion of line
separator as defined by
the system property line.separator.
Not all platforms use
the newline character ('\n')
to terminate lines. Calling
this method to terminate
each output line is
therefore preferred to writing
a newline character directly.
In general, a Writer
sends its output immediately
to the underlying character
or byte stream. Unless
prompt output is required,
it is advisable to
wrap a BufferedWriter around
any Writer whose write()
operations may be costly,
such as FileWriters and
OutputStreamWriters. For example,
PrintWriter
out = new PrintWriter(new
BufferedWriter(new FileWriter
("foo.out")) will buffer
the PrintWriter's output to
the file. Without buffering,
each invocation of a
print() method would cause
characters to be converted
into bytes that would
then be written immediately
to the file, which
can be very inefficient.
;
Button;A class that produces
a labeled button component.
;