Chapter 09 - API Programming

J.E.D.I.
API Programming
1.1 Objectives
In this section, we will be discussing on what APIs are and how we could build ones
ourselves. On top of the concepts of encapsulation, inheritance, and polymorphism, we
additionally discuss the concept of packages and how it is related to the concept of API
programming.
At the end of the lesson, the student should be able to:

Describe the relation of encapsulation, inheritance, and polymorphism to the
concept of APIs
Create packages as a step to an incremental build of an API
Enumerate some APIs available to and in Java
1.2 Introduction
Prior to this chapter, we have looked on certain OO principles such as encapsulation,
inheritance, and polymorphism and how they are implemented in Java. Although they
serve a number of purpose, we focus on how they serve the purpose of API
programming, albeit simplistically.
Firstly, on encapsulation: remember that encapsulation allows a programmer to hide

implementation details on certain functionalities in a class, and just provide some
mechanism to have other classes use the methods and take advantage of its function. In
relation to API programming, creating an API would have you encapsulate certain details
as to how components of your API fully work in order to simplify the usage of your API,
and thus avoiding the possibility of making its usage cumbersome. This promotes
reusability of your code. Another point on encapsulation is that it helps you secure your
code in that the access to critical parts of your code are limited and regulated, especially
if your program's task is to handle sensitive data. Remember that since your API can be
reused, encapsulation will help you ensure that the programs in your API will function
properly.
On inheritance, this helps you in customizing an existing API, and thus build your own
API out of it. Of course, this also sets the precedent that other programmers who would
want to use your API but would want to modify it to suit their needs on specific
scenarios, would have them extend your API and create their own version for their own
needs. Again, the concept of reusability of code under object oriented programming is
once again promoted.
Finally, concepts in polymorphism, particularly interfaces and abstract classes, helps in

defining a framework through which your API can be built. As mentioned before that
polymorphism is closely tied with inheritance, interfaces and abstract classes help you
discipline your code in that classes that implement an interface or extend an abstract
class are forced to follow the form prescribed by their superclasses. As such, this helps
give the classes under a particular API a level of uniformity.
Introduction to Programming I 1
J.E.D.I.
Now that we have established the importance of OO concepts of encapsulation,

inheritance, and polymorphism in API programming, we look into one more concept that
would serve our purpose of API programming. We now take a look on packages, how
they are used, and how they can be created.
1.3 Packages
Packages are Javas means of grouping related classes and interfaces together in a
single unit. This powerful feature provides for a convenient mechanism for managing a
large group of classes and interfaces while avoiding potential naming conflicts.
1.3.1 Importing Packages

To be able to use classes outside of the package you are currently working in, you need
to import the package of those classes. By default, all your Java programs import the
java.lang.* package, that is why you can use classes like String and Integers inside the
program eventhough you haven't imported any packages.
The syntax for importing packages is as follows,
import <nameOfPackage>;
For example, if you want to use the class Color inside package awt, you have to type the
following,
import java.awt.Color;
import java.awt.*;
The first statement imports the specific class Color while the other imports all of the
classes in the java.awt package.
Another way to import classes from other packages is through explicit package
referencing. This is done by using the package name to declare an object of a class.
java.awt.Color color;
1.3.2 Creating your own packages

To create our own package, we write,
package <packageName>;
Suppose we want to create a package where we will place our StudentRecord class,
together with other related classes. We will call our package, schoolClasses.
The first thing you have to do is create a folder named schoolClasses. Copy all the
classes that you want to belong to this package inside this folder. After copying, add the
following code at the top of the class file. For example,
package schoolClasses;
public class StudentRecord

{
private String name;
private String address;
private int age;
:
J.E.D.I.
Packages can also be nested. In this case, the Java interpreter expects the directory
structure containing the executable classes to match the package hierarchy.
1.3.3 Setting the CLASSPATH

Now, suppose we place the package schoolClasses under the C:\ directory. We need to
set the classpath to point to that directory so that when we try to run it, the JVM will be
able to see where our classes are stored.
Before we discuss how to set the classpath, let us take a look at an example on what will
happen if we don't set the classpath.
Suppose we compile and then run the StudentRecord class we wrote in the last section,
C:\schoolClasses>javac StudentRecord.java
C:\schoolClasses>java StudentRecord
Exception in thread "main" java.lang.NoClassDefFoundError:
StudentRecord (wrong name: schoolClasses/StudentRecord)
at java.lang.ClassLoader.defineClass1(Native Method)
at java.lang.ClassLoader.defineClass(Unknown Source)
at java.security.SecureClassLoader.defineClass(Unknown
Source)
at java.net.URLClassLoader.defineClass(Unknown Source)
at java.net.URLClassLoader.access$100(Unknown Source)
at java.net.URLClassLoader$1.run(Unknown Source)
at java.security.AccessController.doPrivileged(Native
Method)
at java.net.URLClassLoader.findClass(Unknown Source)
at java.lang.ClassLoader.loadClass(Unknown Source)
at sun.misc.Launcher$AppClassLoader.loadClass(Unknown
Source)
at java.lang.ClassLoader.loadClass(Unknown Source)
at java.lang.ClassLoader.loadClassInternal(Unknown
Source)
We encounter a NoClassDefFoundError which means that Java did not know where to
look for your class. The reason for this is that your class StudentRecord now belongs to a
package named studentClasses. If we want to run our class, we jave to tell Java about
its full class name which is schoolClasses.StudentRecord. We also have to tell JVM
where to look for our packages, which in this case is in location C:\. To do this, we must
set the classpath.
To set the classpath in Windows, we type this at the command prompt,
C:\schoolClasses> set classpath=C:\
where C:\ is the directory in which we have placed the packages. After setting the
classpath, we can now run our program anywhere by typing,
C:\schoolClasses> java schoolClasses.StudentRecord
For Unix base systems, suppose we have our classes in the directory
/usr/local/myClasses, we write,
export classpath=/usr/local/myClasses
Take note that you can set the classpath anywhere. You can also set more than one
classpath, we just have to separate them by ;(for windows) and : (for Unix based
J.E.D.I.
systems). For example,
set classpath=C:\myClasses;D:\;E:\MyPrograms\Java
and for Unix based systems,
export classpath=/usr/local/java:/usr/myClasses
1.4 Survey of Java APIs

As you have already known, Java has in itself a core API that allows programmers to
include this in their own Java programs to provide certain functionalities to suit their
needs. The core API has packages which you can also consider as APIs in that each of
them contain classes that contribute to a specific function. Below is a table listing the
packages under the core API of Java Standard Edition version 1.6, together with the
summary of the functionalities of their enclosed classes:
Packages
Provides the classes necessary to create
java.applet an applet and the classes an applet uses
to communicate with its applet context.
Contains all of the classes for creating

java.awt user interfaces and for painting graphics
and images.
java.awt.color Provides classes for color spaces.
Provides interfaces and classes for

java.awt.datatransfer transferring data between and within
applications.
Drag and Drop is a direct manipulation

gesture found in many Graphical User
Interface systems that provides a
java.awt.dnd
mechanism to transfer information
between two entities logically associated
with presentation elements in the GUI.

java.awt.event dealing with different types of events
fired by AWT components.
Provides classes and interface relating to

java.awt.font
fonts.
Provides the Java 2D classes for defining

java.awt.geom and performing operations on objects
related to two-dimensional geometry.
Provides classes and interfaces for the

java.awt.im
input method framework.
J.E.D.I.
Provides interfaces that enable the

development of input methods that can
java.awt.im.spi
be used with any Java runtime
environment.
Provides classes for creating and

java.awt.image
modifying images.
Provides classes and interfaces for

java.awt.image.renderable producing rendering-independent
images.
Provides classes and interfaces for a

java.awt.print
general printing API.
Contains classes related to developing

java.beans beans -- components based on the
JavaBeansTM architecture.
Provides classes and interfaces relating

java.beans.beancontext
to bean context.
Provides for system input and output

java.io through data streams, serialization and
the file system.
Provides classes that are fundamental to

java.lang the design of the Java programming
language.
Provides library support for the Java

java.lang.annotation programming language annotation
facility.
Provides services that allow Java

programming language agents to
java.lang.instrument
instrument programs running on the
JVM.
Provides the management interface for

monitoring and management of the Java
java.lang.management virtual machine as well as the operating
system on which the Java virtual
machine is running.
Provides reference-object classes, which

java.lang.ref support a limited degree of interaction
with the garbage collector.

java.lang.reflect obtaining reflective information about
classes and objects.
Provides classes for performing

arbitrary-precision integer arithmetic
java.math
(BigInteger) and arbitrary-precision
decimal arithmetic (BigDecimal).
J.E.D.I.
Provides the classes for implementing

java.net
networking applications.
Defines buffers, which are containers for

java.nio data, and provides an overview of the
other NIO packages.
Defines channels, which represent

connections to entities that are capable
of performing I/O operations, such as
java.nio.channels
files and sockets; defines selectors, for
multiplexed, non-blocking I/O
operations.
Service-provider classes for the

java.nio.channels.spi
java.nio.channels package.
Defines charsets, decoders, and

java.nio.charset encoders, for translating between bytes
and Unicode characters.
Service-provider classes for the

java.nio.charset.spi
java.nio.charset package.
java.rmi Provides the RMI package.
Provides support for RMI Object

java.rmi.activation
Activation.
Provides classes and interface for RMI

java.rmi.dgc
distributed garbage-collection (DGC).
Provides a class and two interfaces for

java.rmi.registry
the RMI registry.

java.rmi.server
supporting the server side of RMI.
Provides the classes and interfaces for

java.security
the security framework.
The classes and interfaces in this

java.security.acl package have been superseded by
classes in the java.security package.

parsing and managing certificates,
java.security.cert
certificate revocation lists (CRLs), and
certification paths.
Provides interfaces for generating RSA

(Rivest, Shamir and Adleman
AsymmetricCipher algorithm) keys as
java.security.interfaces defined in the RSA Laboratory Technical
Note PKCS#1, and DSA (Digital
Signature Algorithm) keys as defined in
NIST's FIPS-186.
J.E.D.I.
Provides classes and interfaces for key

java.security.spec specifications and algorithm parameter
specifications.
Provides the API for accessing and

processing data stored in a data source
java.sql
(usually a relational database) using the
JavaTM programming language.

handling text, dates, numbers, and
java.text
messages in a manner independent of
natural languages.
Service provider classes for the classes

java.text.spi
in the java.text package.
Contains the collections framework,

legacy collection classes, event model,
date and time facilities,
java.util internationalization, and miscellaneous
utility classes (a string tokenizer, a
random-number generator, and a bit
array).
Utility classes commonly useful in

java.util.concurrent
concurrent programming.
A small toolkit of classes that support

java.util.concurrent.atomic lock-free thread-safe programming on
single variables.
Interfaces and classes providing a

framework for locking and waiting for
java.util.concurrent.locks
conditions that is distinct from built-in
synchronization and monitors.
Provides classes for reading and writing

the JAR (Java ARchive) file format,
java.util.jar
which is based on the standard ZIP file
format with an optional manifest file.
Provides the classes and interfaces of

java.util.logging the JavaTM 2 platform's core logging
facilities.
This package allows applications to store

java.util.prefs and retrieve user and system preference
and configuration data.
Classes for matching character

java.util.regex sequences against patterns specified by
regular expressions.
Service provider classes for the classes

java.util.spi
in the java.util package.
J.E.D.I.
Provides classes for reading and writing

java.util.zip
the standard ZIP and GZIP file formats.
Defines a contract between user-

interface components and an assistive
javax.accessibility
technology that provides access to those
components.
javax.activation
Contains Activity service related

javax.activity exceptions thrown by the ORB
machinery during unmarshalling.
javax.annotation
Facilities for declaring annotation

processors and for allowing annotation
javax.annotation.processing
processors to communicate with an
annotation processing tool environment.

javax.crypto
cryptographic operations.
Provides interfaces for Diffie-Hellman

javax.crypto.interfaces keys as defined in RSA Laboratories'
PKCS #3.
Provides classes and interfaces for key

javax.crypto.spec specifications and algorithm parameter
specifications.
The main package of the Java Image I/O

javax.imageio
API.
A package of the Java Image I/O API

dealing with synchronous notification of
javax.imageio.event
events during the reading and writing of
images.

javax.imageio.metadata dealing with reading and writing
metadata.
Package containing the public classes

javax.imageio.plugins.bmp
used by the built-in BMP plug-in.
Classes supporting the built-in JPEG

javax.imageio.plugins.jpeg
plug-in.

containing the plug-in interfaces for
javax.imageio.spi
readers, writers, transcoders, and
streams, and a runtime registry.

javax.imageio.stream dealing with low-level I/O from files and
streams.
J.E.D.I.
javax.jws
javax.jws.soap
Classes and hierarchies of packages

javax.lang.model used to model the Java programming
language.
Interfaces used to model elements of

javax.lang.model.element
the Java programming language.
Interfaces used to model Java

javax.lang.model.type
programming language types.
Utilities to assist in the processing of

javax.lang.model.util
program elements and types.
Provides the core classes for the Java

javax.management
Management Extensions.
Provides the classes which implement

javax.management.loading
advanced dynamic loading.
Provides the definition of the

javax.management.modelmbean
ModelMBean classes.
Provides the definition of the monitor

javax.management.monitor
classes.
Provides the open data types and Open

javax.management.openmbean
MBean descriptor classes.
Provides the definition of the Relation

javax.management.relation
Service.
Interfaces for remote access to JMX

javax.management.remote
MBean servers.
The RMI connector is a connector for the

JMX Remote API that uses RMI to
javax.management.remote.rmi
transmit client requests to a remote
MBean server.
Provides the definition of the Timer

javax.management.timer
MBean.

javax.naming
accessing naming services.
Extends the javax.naming package to

javax.naming.directory provide functionality for accessing
directory services.
Provides support for event notification

javax.naming.event when accessing naming and directory
services.
J.E.D.I.
Provides support for LDAPv3 extended

javax.naming.ldap
operations and controls.
Provides the means for dynamically

plugging in support for accessing
javax.naming.spi
naming and directory services through
the javax.naming and related packages.
Provides classes for networking

javax.net
applications.
Provides classes for the secure socket

javax.net.ssl
package.
Provides the principal classes and

javax.print interfaces for the JavaTM Print Service
API.
Provides classes and interfaces that

describe the types of JavaTM Print
javax.print.attribute
Service attributes and how they can be
collected into attribute sets.
Package javax.print.attribute.standard
javax.print.attribute.standard contains classes for specific printing
attributes.
Package javax.print.event contains

javax.print.event
event classes and listener interfaces.
javax.rmi Contains user APIs for RMI-IIOP.
javax.rmi.CORBA Contains portability APIs for RMI-IIOP.
Provides implementations of
RMIClientSocketFactory and
javax.rmi.ssl RMIServerSocketFactory over the
Secure Sockets Layer (SSL) or Transport
Layer Security (TLS) protocols.
The scripting API consists of interfaces

and classes that define Java TM Scripting
javax.script
Engines and provides a framework for
their use in Java applications.
This package provides a framework for

javax.security.auth
authentication and authorization.
This package provides the classes

necessary for services to interact with
applications in order to retrieve
information (authentication data
javax.security.auth.callback
including usernames or passwords, for
example) or to display information
(error and warning messages, for
example).
J.E.D.I.
This package contains utility classes

javax.security.auth.kerberos related to the Kerberos network
authentication protocol.
This package provides a pluggable

javax.security.auth.login
authentication framework.
This package provides the interface to

javax.security.auth.spi be used for implementing pluggable
authentication modules.
This package contains the classes that

should be used to store X500 Principal
javax.security.auth.x500
and X500 Private Crendentials in a
Subject.
Provides classes for public key

javax.security.cert
certificates.
Contains class and interfaces for

javax.security.sasl
supporting SASL.
Provides interfaces and classes for I/O,

sequencing, and synthesis of MIDI
javax.sound.midi
(Musical Instrument Digital Interface)
data.
Supplies interfaces for service providers

to implement when offering new MIDI
javax.sound.midi.spi
devices, MIDI file readers and writers, or
sound bank readers.

javax.sound.sampled capture, processing, and playback of
sampled audio data.
Supplies abstract classes for service

providers to subclass when offering new
javax.sound.sampled.spi
audio devices, sound file readers and
writers, or audio format converters.
Provides the API for server side data

javax.sql source access and processing from the
JavaTM programming language.
Standard interfaces and base classes for

javax.sql.rowset
JDBC RowSet implementations.
Provides utility classes to allow

serializable mappings between SQL
javax.sql.rowset.serial
types and data types in the Java
programming language.
The standard classes and interfaces that

a third party vendor has to use in its
javax.sql.rowset.spi
implementation of a synchronization
provider.
J.E.D.I.
Provides a set of "lightweight" (all-Java

language) components that, to the
javax.swing
maximum degree possible, work the
same on all platforms.
Provides classes and interface for

javax.swing.border drawing specialized borders around a
Swing component.
Contains classes and interfaces used by

javax.swing.colorchooser
the JColorChooser component.
Provides for events fired by Swing

javax.swing.event
components.
Contains classes and interfaces used by

javax.swing.filechooser
the JFileChooser component.
Provides one interface and many

abstract classes that Swing uses to
javax.swing.plaf
provide its pluggable look-and-feel
capabilities.
Provides user interface objects built

javax.swing.plaf.basic
according to the Basic look and feel.
Provides user interface objects built

according to the Java look and feel (once
javax.swing.plaf.metal
codenamed Metal), which is the default
look and feel.
Provides user interface objects that

javax.swing.plaf.multi
combine two or more look and feels.
Synth is a skinnable look and feel in

javax.swing.plaf.synth
which all painting is delegated.

javax.swing.table
dealing with javax.swing.JTable.
Provides classes and interfaces that deal

javax.swing.text with editable and noneditable text
components.
Provides the class HTMLEditorKit and

javax.swing.text.html supporting classes for creating HTML
text editors.
Provides the default HTML parser, along

javax.swing.text.html.parser
with support classes.
Provides a class (RTFEditorKit) for

javax.swing.text.rtf
creating Rich-Text-Format text editors.

javax.swing.tree
dealing with javax.swing.JTree.
J.E.D.I.
Allows developers to provide support for

javax.swing.undo undo/redo in applications such as text
editors.
Provides interfaces for tools which can

javax.tools be invoked from a program, for
example, compilers.
Contains three exceptions thrown by the

javax.transaction
ORB machinery during unmarshalling.
Provides the API that defines the

contract between the transaction
manager and the resource manager,
javax.transaction.xa which allows the transaction manager to
enlist and delist resource objects
(supplied by the resource manager
driver) in JTA transactions.
Defines core XML constants and

javax.xml functionality from the XML
specifications.
Provides a runtime binding framework

for client applications including
javax.xml.bind
unmarshalling, marshalling, and
validation capabilities.
Defines annotations for customizing Java

javax.xml.bind.annotation program elements to XML Schema
mapping.
XmlAdapter and its spec-defined sub-

javax.xml.bind.annotation.adapters classes to allow arbitrary Java classes to
be used with JAXB.
This package is implemented by a MIME-

based package processor that enables
javax.xml.bind.attachment the interpretation and creation of
optimized binary data within an MIME-
based package format.
JAXB Provider Use Only: Provides

javax.xml.bind.helpers partial default implementations for some
of the javax.xml.bind interfaces.
javax.xml.bind.util Useful client utility classes.
javax.xml.crypto Common classes for XML cryptography.
DOM-specific classes for the

javax.xml.crypto.dom
javax.xml.crypto package.
Classes for generating and validating

javax.xml.crypto.dsig
XML digital signatures.
DOM-specific classes for the

javax.xml.crypto.dsig.dom
javax.xml.crypto.dsig package.
J.E.D.I.
Classes for parsing and processing

javax.xml.crypto.dsig.keyinfo
KeyInfo elements and structures.
Parameter classes for XML digital

javax.xml.crypto.dsig.spec
signatures.
javax.xml.datatype XML/Java Type Mappings.
javax.xml.namespace XML Namespace processing.
Provides classes allowing the processing

javax.xml.parsers
of XML documents.
Provides the API for creating and

javax.xml.soap
building SOAP messages.
javax.xml.stream
javax.xml.stream.events
javax.xml.stream.util
This package defines the generic APIs

for processing transformation
javax.xml.transform
instructions, and performing a
transformation from source to result.
This package implements DOM-specific

javax.xml.transform.dom
transformation APIs.
This package implements SAX2-specific

javax.xml.transform.sax
transformation APIs.
Provides for StAX-specific transformation

javax.xml.transform.stax
APIs.
This package implements stream- and

javax.xml.transform.stream
URI- specific transformation APIs.
This package provides an API for

javax.xml.validation
validation of XML documents.
This package contains the core JAX-WS

javax.xml.ws
APIs.
This package defines APIs for message

javax.xml.ws.handler
handlers.
This package defines APIs for SOAP

javax.xml.ws.handler.soap
message handlers.
This package defines APIs specific to the

javax.xml.ws.http
HTTP binding.
This package defines APIs specific to the

javax.xml.ws.soap
SOAP binding.
This package defines SPIs for JAX-WS

javax.xml.ws.spi
2.0.
J.E.D.I.
This package provides an object-model

neutral API for the evaluation of XPath
javax.xml.xpath
expressions and access to the evaluation
environment.
This package presents a framework that

allows application developers to make
use of security services like
org.ietf.jgss authentication, data integrity and data
confidentiality from a variety of
underlying security mechanisms like
Kerberos, using a unified API.
Provides the mapping of the OMG

CORBA APIs to the JavaTM programming
language, including the class ORB, which
org.omg.CORBA
is implemented so that a programmer
can use it as a fully-functional Object
Request Broker (ORB).
The CORBA_2_3 package defines

additions to existing CORBA interfaces in
the Java[tm] Standard Edition 6. These
changes occurred in recent revisions to
the CORBA API defined by the
org.omg.CORBA_2_3 OMG. The new methods were added
to interfaces derived from the
corresponding interfaces in the CORBA
package. This provides backward
compatibility and avoids breaking the
JCK tests.
Provides methods for the input and

output of value types, and contains
org.omg.CORBA_2_3.portable
other updates to the
org/omg/CORBA/portable package.
Provides the exceptions used with the

DynAny interface (InvalidValue,
org.omg.CORBA.DynAnyPackage
Invalid, InvalidSeq, and
TypeMismatch).
Provides the exception InvalidName,

which is thrown by the method
ORB.resolve_initial_references and
org.omg.CORBA.ORBPackage
the exception InconsistentTypeCode,
which is thrown by the Dynamic Any
creation methods in the ORB class.
Provides a portability layer, that is, a set

of ORB APIs that makes it possible for
org.omg.CORBA.portable
code generated by one vendor to run on
another vendor's ORB.
J.E.D.I.
Provides the user-defined exceptions

org.omg.CORBA.TypeCodePackage BadKind and Bounds, which are thrown
by methods in in the class TypeCode.
org.omg.CosNaming Provides a naming service for Java IDL.
This package contains the following

classes, which are used in
org.omg.CosNaming.NamingContextExtPackage org.omg.CosNaming.NamingContextExt
:
This package contains Exception classes

org.omg.CosNaming.NamingContextPackage
for the org.omg.CosNaming package.
This package contains the Dynamic

module specified in the OMG Portable
org.omg.Dynamic Interceptor specification,
http://cgi.omg.org/cgi-
bin/doc?ptc/2000-08-06, section 21.9.
Provides classes and interfaces that

enable traversal of the data value
org.omg.DynamicAny associated with an any at runtime, and
extraction of the primitive constituents
of the data value.
This package contains classes and

exceptions from the DynAnyFactory
interface of the DynamicAny module
org.omg.DynamicAny.DynAnyFactoryPackage specified in the OMG The Common
Object Request Broker: Architecture and
Specification, http://cgi.omg.org/cgi-
bin/doc?formal/99-10-07, section 9.2.2.
This package contains classes and

exceptions from the DynAny interface of
the DynamicAny module specified in the
org.omg.DynamicAny.DynAnyPackage OMG The Common Object Request
Broker: Architecture and Specification,
bin/doc?formal/99-10-07, section 9.2.
This package contains the IOP module

specified in the OMG document The
Common Object Request Broker:
org.omg.IOP
Architecture and Specification,
bin/doc?formal/99-10-07, section 13.6.
This package contains the exceptions

specified in the IOP::CodeFactory
org.omg.IOP.CodecFactoryPackage
interface (as part of the Portable
Interceptors spec).
This package is generated from the

org.omg.IOP.CodecPackage
IOP::Codec IDL interface definition.
J.E.D.I.
This package contains the Messaging

module specified in the OMG CORBA
org.omg.Messaging Messaging specification,
bin/doc?formal/99-10-07.
Provides a mechanism to register ORB

hooks through which ORB services can
org.omg.PortableInterceptor
intercept the normal flow of execution of
the ORB.
This package contains the exceptions

and typedefs from the ORBInitInfo
local interface of the
org.omg.PortableInterceptor.ORBInitInfoPackage PortableInterceptor module specified
in the OMG Portable Interceptor
specification, http://cgi.omg.org/cgi-
bin/doc?ptc/2000-08-06, section 21.7.2.

making the server side of your
org.omg.PortableServer
applications portable across multivendor
ORBs.
Provides method implementations with

org.omg.PortableServer.CurrentPackage access to the identity of the object on
which the method was invoked.
Encapsulates the processing state of the

org.omg.PortableServer.POAManagerPackage
POAs it is associated with.
Allows programmers to construct object

org.omg.PortableServer.POAPackage implementations that are portable
between different ORB products.

making the server side of your
org.omg.PortableServer.portable
applications portable across multivendor
ORBs.

org.omg.PortableServer.ServantLocatorPackage
locating the servant.
Provides support for the marshalling of

org.omg.SendingContext
value types.
Contains RMI-IIOP Stubs for the Remote

org.omg.stub.java.rmi types that occur in the java.rmi
package.
Provides the interfaces for the Document

Object Model (DOM) which is a
org.w3c.dom
component API of the Java API for XML
Processing.
org.w3c.dom.bootstrap
J.E.D.I.
org.w3c.dom.events
org.w3c.dom.ls
This package provides the core SAX

org.xml.sax
APIs.
This package contains interfaces to

org.xml.sax.ext SAX2 facilities that conformant SAX
drivers won't necessarily support.
This package contains "helper" classes,

org.xml.sax.helpers including support for bootstrapping SAX-
based applications.

Chapter 09 - API Programming

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Chapter 09 - API Programming

Hochgeladen von

Copyright:

Verfügbare Formate

J.E.D.I.

At the end of the lesson, the student should be able to:

Firstly, on encapsulation: remember that encapsulation allows a programmer to hide

Finally, concepts in polymorphism, particularly interfaces and abstract classes, helps in

Now that we have established the importance of OO concepts of encapsulation,

1.3.1 Importing Packages

The syntax for importing packages is as follows,

1.3.2 Creating your own packages

public class StudentRecord

1.3.3 Setting the CLASSPATH

To set the classpath in Windows, we type this at the command prompt,

C:\schoolClasses> set classpath=C:\

C:\schoolClasses> java schoolClasses.StudentRecord

systems). For example,

and for Unix based systems,

1.4 Survey of Java APIs

Contains all of the classes for creating

java.awt.color Provides classes for color spaces.

Provides interfaces and classes for

Drag and Drop is a direct manipulation

Provides interfaces and classes for

Provides classes and interface relating to

Provides the Java 2D classes for defining

Provides classes and interfaces for the

Provides interfaces that enable the

Provides classes for creating and

Provides classes and interfaces for

Provides classes and interfaces for a

Contains classes related to developing

Provides classes and interfaces relating

Provides for system input and output

Provides classes that are fundamental to

Provides library support for the Java

Provides services that allow Java

Provides the management interface for

Provides reference-object classes, which

Provides classes and interfaces for

Provides classes for performing

Provides the classes for implementing

Defines buffers, which are containers for

Defines channels, which represent

Service-provider classes for the

Defines charsets, decoders, and

Service-provider classes for the

java.rmi Provides the RMI package.

Provides support for RMI Object

Provides classes and interface for RMI

Provides a class and two interfaces for

Provides classes and interfaces for

Provides the classes and interfaces for

The classes and interfaces in this

Provides classes and interfaces for

Provides interfaces for generating RSA

Provides classes and interfaces for key

Provides the API for accessing and

Provides classes and interfaces for

Service provider classes for the classes

Contains the collections framework,

Utility classes commonly useful in

A small toolkit of classes that support

Interfaces and classes providing a

Provides classes for reading and writing

Provides the classes and interfaces of