Java Platform, Standard Edition

Java Platform, Standard Edition(Java SE) is acomputing platformfor development and deployment ofportable codefordesktopandserverenvironments.Java SE was formerly known asJava 2 Platform, Standard Edition(J2SE).

The platform uses theJavaprogramming language and is part of theJava software-platformfamily. Java SE defines a range of general-purposeAPIs—such asJava APIsfor theJava Class Library—and also includes theJava Language Specificationand theJava Virtual Machine Specification.OpenJDKis the officialreference implementationsince version 7.

Nomenclature, standards and specifications

The platform was known asJava 2 Platform, Standard EditionorJ2SEfrom version 1.2, until the name was changed toJava Platform, Standard EditionorJava SEin version 1.5. The "SE" is used to distinguish the base platform from the Enterprise Edition (Java EE) and Micro Edition (Java ME) platforms. 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 theJava version history.Starting with J2SE 1.4 (Merlin), Java SE has been developed under theJava Community Process,which produces descriptions of proposed and final specifications for the Java platform calledJava Specification Requests (JSR).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(Java EE) is a related specification that includes all theclassesin Java SE, plus a number that are more useful to programs that run onserversas opposed toworkstations.

Java Platform, Micro Edition(Java ME) 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 phones,PDAsandset-top boxes.

TheJava Runtime Environment (JRE)andJava Development Kit (JDK)are the actual files downloaded and installed on a computer to run or develop Java programs, respectively.

General purpose packages

java.lang

TheJava packagejava.langcontains fundamental classes andinterfacesclosely tied to the language andruntimesystem. This includes the root classes that form theclass hierarchy,types tied to the language definition, basicexceptions,math functions,threading,security functions, as well as some information on the underlying native system. This package contains 22 of 32Errorclasses provided in JDK 6.

The main classes and interfaces injava.langare:

• Object– the class that is the root of every class hierarchy.
• Enum– the base class forenumeration classes(as of J2SE 5.0).
• Class– the class that is the root of the Javareflectionsystem.
• Throwable– the class that is the base class of the exception class hierarchy.
• Error,Exception,andRuntimeException– the base classes for each exception type.
• Thread– the class that allows operations on threads.
• String– the class forstringsandstring literals.
• StringBufferandStringBuilder– classes for performingstring manipulation(StringBuilderas of J2SE 5.0).
• Comparable– the interface that allows generic comparison and ordering of objects (as of J2SE 1.2).
• Iterable– the interface that allows generic iteration using theenhancedforloop(as of J2SE 5.0).
• ClassLoader,Process,Runtime,SecurityManager,andSystem– classes that provide "system operations" that manage thedynamic loadingof classes, creation of externalprocesses,host environment inquiries such as the time of day, and enforcement ofsecurity policies.
• MathandStrictMath– classes that provide basic math functions such assine,cosine,andsquare root(StrictMathas of J2SE 1.3).
• Theprimitive wrapper classesthatencapsulateprimitive typesasobjects.
• The basic exception classes thrown for language-level and other common exceptions.

Classes injava.langare automatically imported into everysource file.

java.lang.ref

Thejava.lang.refpackage provides more flexible types ofreferencesthan 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 an expressive system of references and allows for special behavior for garbage collection. A normal reference in Java is known as a "strong reference". Thejava.lang.refpackage defines three other types of references—soft,weak,and phantom references. Each type of reference is designed for a specific use.

• ASoftReferencecan be used to implement acache.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 are only garbage collected when free memory is low—but again, this is at the garbage collector's discretion. Semantically, a soft reference means, "Keep this object when nothing else references it, unless the memory is needed."
• AWeakReferenceis 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 is garbage collected in the next collection cycle. This behavior is used in the classjava.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 at the next garbage collection."
• APhantomReferenceis used to reference objects that have been marked for garbage collection and have beenfinalized,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 theReferenceclass, which provides theget()methodto return a strong reference to the referent object (ornullif the reference has been cleared or if the reference type is phantom), and theclear()method to clear the reference.

Thejava.lang.refalso defines the classReferenceQueue,which can be used in each of the applications discussed above to keep track of objects that have changed reference type. When aReferenceis created it is optionally registered with a reference queue. The application polls the reference queue to get references that have changed reachability state.

java.lang.reflect

Reflectionis a constituent of theJavaAPI that lets Java code examine and "reflect" on Java components at runtime and use the reflected members. Classes in thejava.lang.reflectpackage, along withjava.lang.Classandjava.lang.Packageaccommodate applications such asdebuggers,interpreters,object inspectors,class browsers,and services such as objectserializationandJavaBeansthat 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,andconstructorscan all be discovered and used at runtime. Reflection is supported bymetadatathat the JVM has about the program.

Techniques

There are basic techniques involved in reflection:

• Discovery – this 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 theObject.getClass()method to get the object'sClass.TheClassobject has several methods for discovering the contents of the class, for example:

• getMethods()– returns an array ofMethodobjects representing all the public methods of the class or interface
• getConstructors()– returns an array ofConstructorobjects representing all the public constructors of the class
• getFields()– returns an array ofFieldobjects representing all the public fields of the class or interface
• getClasses()– returns an array ofClassobjects representing all the public classes and interfaces that are members (e.g.inner classes) of the class or interface
• getSuperclass()– returns theClassobject representing the superclass of the class or interface (nullis returned for interfaces)
• getInterfaces()– returns an array ofClassobjects representing all the interfaces that are implemented by the class or interface

Use by name

TheClassobject can be obtained either through discovery, by using theclass literal(e.g.MyClass.class) or by using the name of the class (e.g.Class.forName( "mypackage.MyClass" )). With aClassobject, memberMethod,Constructor,orFieldobjects can be obtained using the symbolic name of the member. For example:

• getMethod( "methodName", Class...)– returns theMethodobject representing the public method with the name "methodName" of the class or interface that accepts the parameters specified by theClass...parameters.
• getConstructor(Class...)– returns theConstructorobject representing the public constructor of the class that accepts the parameters specified by theClass...parameters.
• getField( "fieldName" )– returns theFieldobject representing the public field with the name "fieldName" of the class or interface.

Method,Constructor,andFieldobjects can be used to dynamically access the represented member of the class. For example:

• Field.get(Object)– returns anObjectcontaining the value of the field from the instance of the object passed toget().(If theFieldobject represents a static field then theObjectparameter is ignored and may benull.)
• Method.invoke(Object, Object...)– returns anObjectcontaining the result of invoking the method for the instance of the firstObjectparameter passed toinvoke().The remainingObject...parameters are passed to the method. (If theMethodobject represents astatic methodthen the firstObjectparameter is ignored and may benull.)
• Constructor.newInstance(Object...)– returns the newObjectinstance from invoking the constructor. TheObject...parameters are passed to the constructor. (Note that the parameterless constructor for a class can also be invoked by callingnewInstance().)

Arrays and proxies

Thejava.lang.reflectpackage also provides anArrayclass that contains static methods for creating and manipulating array objects, and since J2SE 1.3, aProxyclass that supports dynamic creation of proxy classes that implement specified interfaces.

The implementation of aProxyclass is provided by a supplied object that implements theInvocationHandlerinterface. TheInvocationHandler'sinvoke(Object, Method, Object[])method is called for each method invoked on the proxy object—the first parameter is the proxy object, the second parameter is theMethodobject 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 anObjectresult that contains the result returned to the code that called the proxy interface method.

java.io

Thejava.iopackage contains classes that supportinput and output.The classes in the package are primarilystream-oriented;however, a class forrandom accessfilesis also provided. The central classes in the package areInputStreamandOutputStream,which areabstractbase classes for reading from and writing tobyte streams,respectively. The related classesReaderandWriterare abstract base classes for reading from and writing tocharacterstreams, respectively. The package also has a few miscellaneous classes to support interactions with the hostfile system.

Streams

The stream classes follow thedecorator patternby 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 data

The stream subclasses are named using the namingpatternXxxStreamTypewhereXxxis the name describing the feature andStreamTypeis one ofInputStream,OutputStream,Reader,orWriter.

The following table shows the sources/destinations supported directly by thejava.iopackage:

Source/Destination	Name	Stream types	In/out	Classes
bytearray(byte[])	ByteArray	byte	in, out	ByteArrayInputStream,ByteArrayOutputStream
chararray (char[])	CharArray	char	in, out	CharArrayReader,CharArrayWriter
file	File	byte,char	in, out	FileInputStream,FileOutputStream,FileReader,FileWriter
string(StringBuffer)	String	char	in, out	StringReader,StringWriter
thread(Thread)	Piped	byte,char	in, out	PipedInputStream,PipedOutputStream,PipedReader,PipedWriter

Other standard library packages provide stream implementations for other destinations, such as theInputStreamreturned by thejava.net.Socket.getInputStream()method or the Java EEjavax.servlet.ServletOutputStreamclass.

Data type handling and processing or filtering of stream data is accomplished through streamfilters.The filter classes all accept another compatible stream object as a parameter to the constructor anddecoratethe enclosed stream with additional features. Filters are created by extending one of the base filter classesFilterInputStream,FilterOutputStream,FilterReader,orFilterWriter.

TheReaderandWriterclasses are really just byte streams with additional processing performed on the data stream to convert the bytes to characters. They use the defaultcharacter encodingfor the platform, which as of J2SE 5.0 is represented by theCharsetreturned by thejava.nio.charset.Charset.defaultCharset()static method. TheInputStreamReaderclass converts anInputStreamto aReaderand theOutputStreamWriterclass converts anOutputStreamto aWriter.Both these classes have constructors that support specifying the character encoding to use. If no encoding is specified, the program uses the default encoding for the platform.

The following table shows the other processes and filters that thejava.iopackage directly supports. All these classes extend the correspondingFilterclass.

Operation	Name	Stream types	In/out	Classes
buffering	Buffered	byte,char	in, out	BufferedInputStream,BufferedOutputStream,BufferedReader,BufferedWriter
"push back" last value read	Pushback	byte,char	in	PushbackInputStream,PushbackReader
read/writeprimitive types	Data	byte	in, out	DataInputStream,DataOutputStream
object serialization(read/write objects)	Object	byte	in, out	ObjectInputStream,ObjectOutputStream

Random access

TheRandomAccessFileclass supportsrandom accessreading and writing of files. The class uses afile pointerthat 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 theseek(long)orskipBytes(int)methods. The current position of the file pointer is returned by thegetFilePointer()method.

File system

TheFileclass represents afileordirectorypathin afile system.Fileobjects support the creation, deletion and renaming of files and directories and the manipulation offile attributessuch asread-onlyandlast modified timestamp.Fileobjects that represent directories can be used to get a list of all the contained files and directories.

TheFileDescriptorclass is afile descriptorthat represents a source or sink (destination) of bytes. Typically this is a file, but can also be aconsoleornetwork socket.FileDescriptorobjects are used to createFilestreams. They are obtained fromFilestreams andjava.netsockets and datagram sockets.

java.nio

Main article:Non-blocking I/O (Java)

In J2SE 1.4, the packagejava.nio(NIO or Non-blocking I/O) was added to supportmemory-mapped I/O,facilitatingI/Ooperations closer to the underlying hardware with sometimes dramatically better performance. Thejava.niopackage provides support for a number of buffer types. The subpackagejava.nio.charsetprovides support for differentcharacter encodingsfor character data. The subpackagejava.nio.channelsprovides support forchannels,which represent connections to entities that are capable of performing I/O operations, such as files and sockets. Thejava.nio.channelspackage also provides support for fine-grained locking of files.

java.math

Thejava.mathpackage supportsmultiprecision arithmetic(including modular arithmetic operations) and provides multiprecision prime number generators used for cryptographic key generation. The main classes of the package are:

• BigDecimal– provides arbitrary-precision signed decimal numbers.BigDecimalgives the user control over rounding behavior throughRoundingMode.
• BigInteger– provides arbitrary-precision integers. Operations onBigIntegerdo notoverflowor lose precision. In addition to standard arithmetic operations, it providesmodular arithmetic,GCDcalculation,primality testing,prime numbergeneration,bitmanipulation, and other miscellaneous operations.
• MathContext– encapsulate the context settings that describe certain rules for numerical operators.
• RoundingMode– an enumeration that provides eight rounding behaviors.

java.net

Thejava.netpackage provides special IO routines for networks, allowingHTTPrequests, as well as other common transactions.

java.text

Thejava.textpackage implements parsing routines for strings and supports various human-readable languages and locale-specific parsing.

java.util

Data structuresthat aggregate objects are the focus of thejava.utilpackage. Included in the package is theCollections API,an organized data structure hierarchy influenced heavily by thedesign patternsconsiderations.

Special purpose packages

java.applet

Main article:Java applet

Created to supportJava appletcreation, thejava.appletpackage lets applications 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 signatureto 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 the sandbox restrictions. Digital certificates are issued bycertificate authorities.

java.beans

Main article:JavaBeans

Included in thejava.beanspackage are various classes for developing and manipulating beans, reusable components defined by theJavaBeans architecture.The architecture provides mechanisms for manipulating properties of components and firing events when those properties change.

The APIs injava.beansare intended for use by a bean editing tool, in which beans can be combined, customized, and manipulated. One type of bean editor is aGUIdesigner in anintegrated development environment.

java.awt

Main article:Abstract Window Toolkit

Thejava.awt,or Abstract Window Toolkit, provides access to a basic set ofGUIwidgets 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 basiclayout managers,a datatransfer package for use with theClipboardandDrag and Drop,the interface toinput devicessuch asmiceandkeyboards,as well as access to thesystem trayon supporting systems. This package, along withjavax.swingcontains the largest number of enums (7 in all) in JDK 6.

java.rmi

Main article:Java Remote Method Invocation

Thejava.rmipackage providesJava remote method invocationto supportremote procedure callsbetween two java applications running in differentJVMs.

java.security

Support for security, including the message digest algorithm, is included in thejava.securitypackage.

java.sql

Main article:Java Database Connectivity

An implementation of theJDBCAPI (used to accessSQLdatabases) is grouped into thejava.sqlpackage.

javax.rmi

Main article:RMI-IIOP

Thejavax.rmipackage provided support for the remote communication between applications, using the RMI over IIOP protocol. This protocol combines RMI and CORBA features.

Java SE Core Technologies - CORBA / RMI-IIOP

javax.swing

Main article:Swing (Java)

Swingis a collection of routines that build onjava.awtto provide a platform independentwidget toolkit.javax.swinguses the 2D drawing routines to render the user interface components instead of relying on the underlying nativeoperating systemGUI support.

This package contains the largest number of classes (133 in all) in JDK 6. This package, along withjava.awtalso contains the largest number of enums (7 in all) in JDK 6. It supports 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–controllerpattern, which loosens thecouplingbetween 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.

javax.swing.text.html.parser

Thejavax.swing.text.html.parserpackage provides the error tolerant HTML parser that is used for writing various web browsers and web bots.

javax.xml.bind.annotation

Thejavax.xml.bind.annotationpackage contained the largest number of Annotation Types (30 in all) in JDK 6. It defines annotations for customizing Java program elements to XML Schema mapping.

OMG packages

org.omg.CORBA

Main article:CORBA

Theorg.omg.CORBApackage provided support for the remote communication between applications using theGeneral Inter-ORB Protocoland supports other features of thecommon object request broker architecture.Same asRMIandRMI-IIOP,this package is for calling remote methods of objects on other virtual machines (usually via network).

This package contained the largest number ofExceptionclasses (45 in all) in JDK 6. From all communication possibilities CORBA is portable between various languages; however, with this comes more complexity.

These packages were deprecated in Java 9 and removed from Java 11.

org.omg.PortableInterceptor

Theorg.omg.PortableInterceptorpackage contained the largest number of interfaces (39 in all) in JDK 6. It provides a mechanism to register ORB hooks through which ORB services intercept the normal flow of execution of the ORB.

Security

Several critical security vulnerabilities have been reported.Security alerts from Oracle announce critical security-related patches to Java SE.

External links

• Oracle Technology Network's Java SE
• Java SE 19 API Javadocs
• Java SE API documentation
• JSR 270(Java SE 6)
• 1.8
• 1.7
• 1.6