- Java Platform, Standard Edition
Java Platform, Standard Edition or Java SE is a widely used platform for
programming in the Java language. It is the Java Platform used to deploy portable applications for general use.In practical terms, Java SE consists of a virtual machine, which must be used to run Java programs, together with a set of libraries (or "packages") needed to allow the use of
file system s, networks, graphical interfaces, and so on, from within those programs.It must be noted that the expressions such as "super, this" or the return type "void" and the method "main()" are not part of the class hierarchy. Instead they are implemented in the JVM architecture.
Nomenclature, standards and specifications
Java SE was known as "Java 2 Platform, Standard Edition" or "J2SE" from version 1.2 until version 1.5. "SE" is used to distinguish the base platform from Java EE and Java ME. The "2" was originally intended to emphasize the major changes introduced in version 1.2, but was removed in version 1.6. The naming convention has been changed several times over the
Java version history .Starting with J2SE 1.4 ("Merlin"), Java SE has been developed under the
Java Community Process . JSR 59 was the umbrella specification for J2SE 1.4 and JSR 176 specified J2SE 5.0 ("Tiger"). Java SE 6 ("Mustang") was released under JSR 270.Java Platform, Enterprise Edition is a related specification which includes all of the classes in Java SE, plus a number which are more useful to programs which run on servers as opposed toworkstation s.Java Platform, Micro Edition is a related specification intended to provide a certified collection of Java APIs for the development of software for small, resource-constrained devices such ascell phone s,
PDAs andset-top box es.The
JRE and package=java. _ja. interfaces closely tied to the language andruntime system. This includes the root classes that form theclass hierarchy , types tied to the language definition, basic exceptions, math functions, threading, security functions, as well as some information on the underlying native system. This package contains 22 of 32Error
classes provided in JDK 6.The main classes in
java.lang
are:
* – the class that is the root of every class hierarchy. "(See alsoJava syntax#Methods in the Object class .)"
* – the base class for enumeration classes (as of J2SE 5.0).
* – the class that is the root of the Java reflection system.
* – the class that is the base class of the exception class hierarchy.
*, Javadoc:SE|java/lang|Exception, and Javadoc:SE|java/lang|RuntimeException – the base classes for each exception type.
* – the class that allows operations on threads.
* – the class for strings andstring literal s.
* and Javadoc:SE|java/lang|StringBuilder – classes for performing string manipulation (StringBuilder
as of J2SE 5.0).
* – the interface that allows generic comparison and ordering of objects (as of J2SE 1.2).
* – the interface that allows generic iteration using the enhancedfor
loop (as of J2SE 5.0).
*, Javadoc:SE|java/lang|Process, Javadoc:SE|java/lang|Runtime,Javadoc:SE|java/lang|SecurityManager, and Javadoc:SE|java/lang|System – classes that provide "system operations" that manage the dynamic loading of classes, creation of external processes, host environment inquiries such as the time of day, and enforcement of security policies.
* and Javadoc:SE|java/lang|StrictMath – classes that provide basic math functions such assine ,cosine , andsquare root (StrictMath
as of J2SE 1.3).
* Theprimitive wrapper class es that encapsulateprimitive type s as objects.
* The basic exception classes thrown for language-level and other common exceptions.Classes in
java.lang
are automatically imported into everysource file .
= Javadoc:SE|package=java.lang.ref|java/lang/ref =The
java.lang.ref
package provides more flexible types of references than are otherwise available, permitting limited interaction between the application and theJava Virtual Machine (JVM) garbage collector. It is an important package, central enough to the language for the language designers to give it a name that starts with "java.lang", but it is somewhat special-purpose and not used by a lot of developers. This package was added in J2SE 1.2.Java has a more expressive system of reference than most other garbage-collected
programming language s, which allows for special behavior for garbage collection. A normal reference in Java is known as a "strong reference". Thejava.lang.ref
package defines three other types of references—"soft", "weak", and "phantom" references. Each type of reference is designed for a specific use.A Javadoc:SE|java/lang/ref|SoftReference can be used to implement a
cache . An object that is not reachable by a strong reference (that is, not "strongly reachable"), but is referenced by a soft reference is called "softly reachable". A softly reachable object may be garbage collected at the discretion of the garbage collector. This generally means that softly reachable objects will only be garbage collected when free memory is low, but again, it is at the discretion of the garbage collector. Semantically, a soft reference means "keep this object unless the memory is needed."A Javadoc:SE|java/lang/ref|WeakReference is used to implement weak maps. An object that is not strongly or softly reachable, but is referenced by a weak reference is called "
weakly reachable ". A weakly reachable object will be garbage collected during the next collection cycle. This behavior is used in the class Javadoc:SE|package=java.util|java/util|WeakHashMap. A weak map allows the programmer to put key/value pairs in the map and not worry about the objects taking up memory when the key is no longer reachable anywhere else. Another possible application of weak references is thestring intern pool . Semantically, a weak reference means "get rid of this object when nothing else references it."A Javadoc:SE|java/lang/ref|PhantomReference is used to reference objects that have been marked for garbage collection and have been finalized, but have not yet been reclaimed. An object that is not strongly, softly or weakly reachable, but is referenced by a phantom reference is called "phantom reachable". This allows for more flexible cleanup than is possible with the finalization mechanism alone. Semantically, a phantom reference means "this object is no longer needed and has been finalized in preparation for being collected."
Each of these reference types extends the Javadoc:SE|java/lang/ref|Reference class which provides the Javadoc:SE|name=get()|java/lang/ref|Reference|get() method to return a strong reference to the referent object (or
null
if the reference has been cleared or if the reference type is phantom), and the Javadoc:SE|name=clear()|java/lang/ref|Reference|clear() method to clear the reference.The
java.lang.ref
also defines the class Javadoc:SE|java/lang/ref|ReferenceQueue, which can be used in each of the applications discussed above to keep track of objects that have changed reference type. When aReference
is created it is optionally registered with a reference queue. The application polls the reference queue to get references that have changed reachability state.
= Javadoc:SE|package=java.lang.reflect|java/lang/reflect =Reflection is a constituent of the Java API which enables Java code to examine and "reflect" upon Java components at runtime and to use the reflected members. Classes in this package, along with
java.lang.Class
and Javadoc:SE|package=java. _ja. Package accommodate applications such asdebugger s, interpreters, object inspectors,class browser s, and services such as objectserialization andJavaBeans that need access to either the public members of a target object (based on its runtime class) or the members declared by a given class. This package was added in JDK 1.1.Reflection is used to instantiate classes and invoke methods using their names, a concept that allows for dynamic programming. Classes, interfaces, methods, fields, and constructors can all be discovered and used at runtime. Reflection is supported by
metadata that the JVM has about the program. There are two basic techniques involved in reflection:# "Discovery" involves taking an object or class and discovering the members, superclasses, implemented interfaces, and then possibly using the discovered elements.
# "Use by name" involves starting with the symbolic name of an element and using the named element.Discovery
Discovery typically starts with an object and calling the Javadoc:SE|java/lang|Object|getClass() method to get the object's
Class
. TheClass
object has several methods for discovering the contents of the class, for example:
* – returns an array of Javadoc:SE|java/lang/reflect|Method objects representing all the public methods of the class or interface
* – returns an array of Javadoc:SE|java/lang/reflect|Constructor objects representing all the public constructors of the class
* – returns an array of Javadoc:SE|java/lang/reflect|Field objects representing all the public fields of the class or interface
* – returns an array ofClass
objects representing all the public classes and interfaces that are members (e.g.inner class es) of the class or interface
* – return theClass
object representing the superclass of the class or interface (null
is returned for interfaces)
* – returns an array ofClass
objects representing all the interfaces that are implemented by the class or interfaceUse by name
The
Class
object can be obtained either through discovery, by using the "class literal" (e.g.MyClass.class
) or by using the name of the class (e.g. Javadoc:SE|name=Class.forName("mypackage.MyClass")|java/lang|Class|forName(java.lang.String)). With aClass
object, memberMethod
,Constructor
, orField
objects can be obtained using the symbolic name of the member. For example:
* – returns theMethod
object representing the public method with the name "methodName" of the class or interface that accepts the parameters specified by theClass...
parameters.
* – returns theConstructor
object representing the public constructor of the class that accepts the parameters specified by theClass...
parameters.
* – returns theField
object representing the public field with the name "fieldName" of the class or interface.Method
,Constructor
, andField
objects can be used to dynamically access the represented member of the class. For example:
* – returns anObject
containing the value of the field from the instance of the object passed toget()
. (If theField
object represents a static field then theObject
parameter is ignored and may benull
.)
* – returns anObject
containing the result of invoking the method for the instance of the firstObject
parameter passed toinvoke()
. The remainingObject...
parameters are passed to the method. (If theMethod
object represents astatic method then the firstObject
parameter is ignored and may benull
.)
* – returns the newObject
instance from invoking the constructor. TheObject...
parameters are passed to the constructor. (Note that the parameterless constructor for a class can also be invoked by calling Javadoc:SE|name=newInstance()|java/lang|Class|newInstance().)Arrays and proxies
The
java.lang.reflect
package also provides an Javadoc:SE|java/lang/reflect|Array class that contains static methods for creating and manipulating array objects, and since J2SE 1.3, a Javadoc:SE|java/lang/reflect|Proxy class that supports dynamic creation of proxy classes that implement specified interfaces.The implementation of a
Proxy
class is provided by a supplied object that implements the Javadoc:SE|java/lang/reflect|InvocationHandler interface. TheInvocationHandler
's Javadoc:SE|name=invoke(Object, Method, Object[] )|java/lang/reflect|InvocationHandler|invoke(java.lang.Object,java.lang.reflect.Method,java.lang.Object[] ) method is called for each method invoked on the proxy object—the first parameter is the proxy object, the second parameter is theMethod
object representing the method from the interface implemented by the proxy, and the third parameter is the array of parameters passed to the interface method. Theinvoke()
method returns anObject
result that contains the result returned to the code that called the proxy interface method.
= Javadoc:SE|package=java.io|java/io =The
java.io
package contains classes that support input and output. The classes in the package are primarily stream-oriented; however, a class forrandom access files is also provided. The central classes in the package are Javadoc:SE|java/io|InputStream and Javadoc:SE|java/io|OutputStream which are abstract base classes for reading from and writing tobyte stream s, respectively. The related classes Javadoc:SE|java/io|Reader and Javadoc:SE|java/io|Writer are abstract base classes for reading from and writing to character streams, respectively. The package also has a few miscellaneous classes to support interactions with the hostfile system .Streams
The stream classes follow the
decorator pattern by extending the base subclass to add features to the stream classes. Subclasses of the base stream classes are typically named for one of the following attributes:
* the source/destination of the stream data
* the type of data written to/read from the stream
* additional processing or filtering performed on the stream dataThe stream subclasses are named using the naming
pattern "XxxStreamType"
where"Xxx"
is the name describing the feature and"StreamType"
is one ofInputStream
,OutputStream
,Reader
, orWriter
.The following table shows the sources/destinations supported directly by the
java.io
package::
Other standard library packages provide stream implementations for other destinations, such as the
InputStream
returned by the Javadoc:SE|package=java.net|java/net|Socket|getInputStream() method or the Java EE Javadoc:EE|package=javax.servlet|javax/servlet|ServletOutputStream class.Data type handling and processing or filtering of stream data is accomplished through stream filters. The filter classes all accept another compatible stream object as a parameter to the constructor and "decorate" the enclosed stream with additional features. Filters are created by extending one of the base filter classes Javadoc:SE|java/io|FilterInputStream, Javadoc:SE|java/io|FilterOutputStream, Javadoc:SE|java/io|FilterReader, or Javadoc:SE|java/io|FilterWriter.
The
Reader
andWriter
classes are really just byte streams with additional processing performed on the data stream to convert the bytes to characters. They use the defaultcharacter encoding for the platform, which as of J2SE 5.0 is represented by the Javadoc:SE|java/nio/charset|Charset returned by the Javadoc:SE|package=java.nio.charset|java/nio/charset|Charset|defaultCharset() static method. The Javadoc:SE|java/io|InputStreamReader class converts anInputStream
to aReader
and the Javadoc:SE|java/io|OutputStreamWriter class converts anOutputStream
to aWriter
. Both these classes have constructors that allow the character encoding to use to be specified—if no encoding is specified then the default encoding for the platform is used.The following table shows the other processes and filters supported directly by the
java.io
package. All of these classes extend the correspondingFilter
class.:
Random access
The Javadoc:SE|java/io|RandomAccessFile class supports "
random access " reading and writing of files. The class uses a "file pointer " that represents a byte-offset within the file for the next read or write operation. The file pointer is moved implicitly by reading or writing and explicitly by calling the Javadoc:SE|name=seek(long)|java/io|RandomAccessFile|seek(long) or Javadoc:SE|name=skipBytes(int)|java/io|RandomAccessFile|skipBytes(int) methods. The current position of the file pointer is returned by the Javadoc:SE|name=getFilePointer()|java/io|RandomAccessFile|getFilePointer() method.File system
The Javadoc:SE|java/io|File class represents a file or directory path in a
file system .File
objects support the creation, deletion and renaming of files and directories and the manipulation offile attribute s such as "read-only" and "last modified timestamp".File
objects that represent directories can be used to get a list of all of the contained files and directories.The Javadoc:SE|java/io|FileDescriptor class is a
file descriptor that represents a source or sink (destination) of bytes. Typically this is a file, but can also be a console ornetwork socket .FileDescriptor
objects are used to createFile
streams. They are obtained fromFile
streams andjava.net
sockets and datagram sockets.
= Javadoc:SE|package=java.nio|java/nio =In J2SE 1.4, the package
java.nio
(NIO or New I/O) was added to supportmemory-mapped I/O , facilitatingIO operations closer to the underlying hardware with sometimes dramatically better performance. Thejava.nio
package provides support for a number of buffer types. The subpackage Javadoc:SE|package=java.nio.charset|java/nio/charset provides support for differentcharacter encoding s for character data. The subpackage Javadoc:SE|package=java.nio.channels|java/nio/channels provides support for "channels," which represent connections to entities that are capable of performing I/O operations, such as files and sockets. Thejava.nio.channels
package also provides support for fine-grained locking of files.
= Javadoc:SE|package=java.math|java/math =The
java.math
package supports multiprecision arithmetic (including modular arithmetic operations) and provides multiprecision prime number generators used for cryptographic key generation. The main classes of the package are:* – provides arbitrary-precision signed decimal numbers.
BigDecimal
gives the user control over rounding behavior throughRoundingMode
.
* – provides arbitrary-precision integers. Operations onBigInteger
do not overflow or lose precision. In addition to standard arithmetic operations, it providesmodular arithmetic , GCD calculation,primality testing ,prime number generation,bit manipulation, and other miscellaneous operations.
* – encapsulate the context settings which describe certain rules for numerical operators.
* – an enumeration that provides eight rounding behaviors.
= Javadoc:SE|package=java.net|java/net =The
java.net
package provides special IO routines for networks, allowingHTTP requests, as well as other common transactions.
= Javadoc:SE|package=java.text|java/text =The
java.text
package implements parsing routines for strings and supports various human-readable languages and locale-specific parsing.
= Javadoc:SE|package=java.util|java/util =Data structure s that aggregate objects are the focus of thejava.util
package. Included in the package is theCollections API , an organized data structure hierarchy influenced heavily by the design patterns considerations.Special purpose packages
= Javadoc:SE|package=java.applet|java/applet =Created to support
Java applet creation, thejava.applet
package allows applications to be downloaded over a network and run within a guarded sandbox. Security restrictions are easily imposed on the sandbox. A developer, for example, may apply adigital signature to an applet, thereby labeling it as safe. Doing so allows the user to grant the applet permission to perform restricted operations (such as accessing the local hard drive), and removes some or all of the sandbox restrictions. Digital certificates are issued by certificate authorities.
= Javadoc:SE|package=java.beans|java/beans =Included in the
java.beans
package are various classes for developing and manipulating beans, reusable components defined by the JavaBeans architecture. The architecture provides mechanisms for manipulating properties of components and firing events when those properties change.Most of the APIs in
java.beans
are intended for use by a bean editing tool, in which beans can be combined, customized and manipulated. One type of bean editor is a GUI designer in anintegrated development environment .
= Javadoc:SE|package=java.awt|java/awt =The
Abstract Window Toolkit provides access to a basic set ofGUI widgets based on the underlying native platform's widget set, the core of the GUI event subsystem, and the interface between the native windowing system and the Java application. It also provides several basic layout managers, a datatransfer package for use with the Clipboard and Drag and Drop, the interface to input devices such as mice and
keyboards, as well as access to thesystem tray on supporting systems. This package, along withjavax.swing
contains the maximum number of enums (7 in all) in JDK 6.
= Javadoc:SE|package=java.rmi|java/rmi =The
java.rmi
package providesJava remote method invocation to supportremote procedure call s between two java applications running in differentJVM s.
= Javadoc:SE|package=java.security|java/security =Support for security, including the message digest algorithm, is included in the
java.security
package.
= Javadoc:SE|package=java.sql|java/sql =An implementation of the
JDBC API (used to accessSQL database s) is grouped into thejava.sql
package.
= Javadoc:SE|package=javax.rmi|javax/rmi =Provides the support for the remote communication between applications, using the RMI over IIOP protocol. This protocol combines RMI and CORBA features.
= Javadoc:SE|package=javax.swing|javax/swing =Swing is a collection of routines that build on
java.awt
to provide a platform independentwidget toolkit . Swing uses the 2D drawing routines to render the user interface components instead of relying on the underlying nativeoperating system GUI support.This package contains the maximum number of classes (133 in all) in JDK 6. This package, along with
java.awt
also contains the maximum number of enums (7 in all) in JDK 6. Thus it is a very rich system in its own right, supporting pluggable looks and feels (PLAFs) so that widgets in the GUI can imitate those from the underlying native system. Design patterns permeate the system, especially a modification of themodel-view-controller pattern, which loosens the coupling between function and appearance. One inconsistency is that (as of J2SE 1.3) fonts are drawn by the underlying native system, and not by Java, limiting text portability. Workarounds, such as using bitmap fonts, do exist. In general, "layouts" are used and keep elements within an aesthetically consistent GUI across platforms.
= Javadoc:SE|package=javax.swing.text.html.parser|javax/swing/text/html/parser =Provides the error tolerant HTML parser that is used for writing various web browsers and web bots.
= Javadoc:SE|package=javax.xml.bind.annotation|javax/xml/bind/annotation =This package contains the maximum number of Annotation Types (29 in all) in JDK 6. It defines annotations for customizing Java program elements to XML Schema mapping.
OMG packages
= Javadoc:SE|package=org.omg.CORBA|org/omg/CORBA =Provides the support for the remote communication between applications using the
General Inter-ORB Protocol and supports other features of the common object request broker architecture. Same as RMI andRMI-IIOP , this package is for calling remote methods of objects on other virtual machines (usually via network).This package contains the maximum number of
Exception
classes (45 in all) in JDK 6. From all communication possibilities CORBA is the most portable between various languages; however, with this comes more complexity.
= Javadoc:SE|package=org.omg.PortableInterceptor|org/omg/PortableInterceptor =This package contains the maximum number of interfaces (39 in all) in JDK 6. It provides a mechanism to register ORB hooks through which ORB services can intercept the normal flow of execution of the ORB.
See also
* Java EE
* Java ME
*Java Class Library External links
* [http://java.sun.com/javase/ Java SE Main page]
*
* [http://java.sun.com/reference/api/index.html Java SE API documentation]
* [http://www.jcp.org/en/jsr/detail?id=270 JSR 270] (Java SE 6)
* [http://www.jcp.org/en/jsr/detail?id=176 JSR 176] (J2SE 5.0)
* [http://www.jcp.org/en/jsr/detail?id=59 JSR 59] (J2SE 1.4)
* Java software development kits (status as of April 2008):
** [https://jdk7.dev.java.net/ 1.7] (early development)
** [http://java.sun.com/javase/6/ 1.6] (stable, current)
** [http://java.sun.com/j2se/1.5.0/ 1.5] (stable)
** [http://java.sun.com/j2se/1.4.2/ 1.4] (stable)
** [http://java.sun.com/j2se/1.3/ 1.3] (obsolete)
** [http://java.sun.com/products/archive/j2se/1.2.2_017/ 1.2] (no longer actively supported)
* [http://community.java.net/jdk/opensource/ Open Source Java]
* [http://java.sun.com/developer/JDCTechTips/index.html Java SE Tech Tips]
Wikimedia Foundation. 2010.