This Specification defines version 12 of the Java Platform, Standard Edition (“Java SE 12”). The Reference Implementation of this Specification is the Java Development Kit, version 12 (“JDK 12”).

This release continues the evolution of the Platform to ensure the broadest possible success of the core Java technology. It contains language preview features to provoke developer feedback based on real world use.

This document directly specifies API features, enhancements, clarifications, and bug fixes. It also specifies features by reference to other Specifications which are revised in Maintenance Releases of existing JSRs. The specifications of these changes are contained in two accompanying documents: Annex 1 is the complete Java SE 12 API Specification and Annex 2 is an annotated API specification showing the exact differences relative to Java SE 11. Informative background for these changes may be found in the list of approved Change Specification Requests for this release.

This Specification includes the Java SE 12 Editions of The Java Language Specification and The Java Virtual Machine Specification in Annex 3. The Java SE 12 Editions contain all corrections and clarifications made since the Java SE 11 Editions, as well as additions for new features.

The Final Release of this Specification is expected to include all of the currently described features and updates; however, further changes may be forthcoming. For example, the Expert Group could determine that a feature is not yet be ready for standardization.

Changes to the Java SE Platform Specification are categorized as either features or enhancements. A feature is, roughly speaking, a change of which at least one of the following statements is true:

• It requires two or more weeks of development effort to design and implement,
• It is a significant change worthy of wide review, or
• It is in high demand by the Java community.

Any addition that is not a feature is considered an enhancement.

There is, obviously, room for judgment when interpreting this definition. In order to maximize the visibility of Platform revisions we generally tend to consider borderline items to be features rather than enhancements.

Some Component JSR Specifications previously incorporated into the Platform are still available separately or have significant Specifications themselves. Changes to their Specifications are therefore made in separate Maintenance Releases. The following existing component JSRs may have Maintenance Releases. These will be incorporated by reference before the Final Release of this Specification as necessary:

JSR 114:	JDBC Rowset Implementations
JSR 199:	Java Compiler API
JSR 221:	JDBC API
JSR 269:	Pluggable Annotation-Processing API

Each Component JSR Specification, or revision thereto, may be related to one or more features in the detailed list below.

Language	Raw String Literals (Preview)
	Switch Expressions (Preview)

Work on features in the Java SE 12 Reference Implementation is organized in terms of JDK Enhancement Proposals (JEPs). Each feature description gives a link to the corresponding JEP document as a convenience, but that document is not a normative part of this Specification. Some features are included in the Java SE 12 Reference Implementation on a preview basis, to gain exposure before achieving permanent status in a later release of the Java SE Platform.

Preview features A preview language or VM feature is a new feature of the Java SE Platform that is fully specified, fully implemented, and yet impermanent. Preview features must possess the following properties:

• High quality. A preview feature must display the same level of technical excellence and finesse as a final and permanent feature of the Java SE Platform.
• Not experimental. A language or VM feature that is considered experimental, risky, incomplete, or unstable must not be accepted as a preview feature in a release of the Java SE Platform.
• Universally available. All preview features included in a Java SE Platform Specification must be supported by every implementation of that Specification.

Implementations of this Specification must:

• support all, and only, the preview features included by this Specification.
• disable all preview features at compile time and run time by default.
• allow the user to indicate to the compiler and the runtime system that the entire set of preview features are to be enabled.
• not allow the user to enable preview features on an individual basis, because they have equal status in the Platform and must be enabled or disabled as a set.

Additional details about preview features, including a description of a feature’s life cycle and the relationship of preview features to Java SE APIs are available in JEP 12 Preview Language and VM Features.

A module is a named set of packages designed for reuse. A specification governed by the JCP defines standard packages, and may group them into one or more standard modules.

This Specification groups the standard packages of the Java SE Platform into 21 standard modules, which we refer to as the Java SE modules. The name of a Java SE module always starts with the string "java.". The complete list of such modules is:

java.base java.compiler java.datatransfer java.desktop java.instrument java.logging java.management

java.management.rmi java.naming java.net.http java.prefs java.rmi java.scripting java.se (aggregator)

java.security.jgss java.security.sasl java.sql java.sql.rowset java.transaction.xa java.xml java.xml.crypto

Compared to Java SE 11, this Specification does not add or remove any modules.

The module graph The Java SE modules depend upon each other as stated in their specifications, which are part of the overall API Specification. The corresponding complete Java SE module graph has too many edges to be displayed easily in visual form; here is the transitive reduction of the directed acyclic graph, in which redundant edges are omitted (click to enlarge):

Here is how to read this visualization of the module graph:

• If one module depends upon another, and it grants implied readability to that module via a requires transitive directive, then there is an edge from the first module to the second.

• At the very bottom is the java.base module, which contains essential classes such as java.lang.Object and java.lang.String. The base module depends upon no module, and every other module depends upon the base module.

• At the top is the java.se module, which gathers together all of the modules that comprise the Java SE Platform. This is an example of an aggregator module, which logically gathers the content of other modules by granting implied readability to them, but adds no content of its own. A run-time system configured to contain the java.se module will contain all of the packages of the Java SE Platform.

A module is a Java SE module — that is, considered part of the Java SE Platform Specification — if and only if it is a standard module reachable from the java.se module.

This Specification incorporates the following subsections by reference from Java SE 9 Platform Specification (JSR 379), “Modules”:

• Constraints on Java SE modules
• Constraints on all modules in an Implementation
• Relaxing strong encapsulation
• Overriding module declarations
• Upgradeable modules

Following the conventions established by the Enhanced Deprecation feature, various modules and APIs were annotated with forRemoval=true in the “APIs Proposed for Removal” section of the Platform Specifications for Java SE 9, Java SE 10, and Java SE 11.

The following individual APIs are removed from this Specification. The number in parentheses indicates the Java SE Platform Specification which first proposed their removal.

Methods

• java.io.FileInputStream.finalize() (10)
• java.io.FileOutputStream.finalize() (10)

The following APIs were proposed for removal by the Platform Specifications for Java SE 9, Java SE 10, and Java SE 11, and continue to be eligible for removal in a future release. They are not removed from this Specification.

Packages 

• java.security.acl (10)

Interfaces 

• java.security.acl.Acl (10)
• java.security.acl.AclEntry (10)
• java.security.acl.Group (10)
• java.security.acl.Owner (10)
• java.security.acl.Permission (10)
• java.util.jar.Pack200.Packer (11)
• java.util.jar.Pack200.Unpacker (11)

Classes 

• java.lang.Compiler (9)
• java.security.Certificate (10)
• java.security.Identity (10)
• java.security.IdentityScope (10)
• java.security.Signer (10)
• java.util.jar.Pack200 (11)

Exceptions 

• java.security.acl.AclNotFoundException (10)
• java.security.acl.LastOwnerException (10)
• java.security.acl.NotOwnerException (10)

Fields 

• javax.management.remote.rmi.RMIConnectorServer.CREDENTIAL_TYPES (10)

Methods 

• java.lang.Runtime.traceInstructions(boolean) (9)
• java.lang.Runtime.traceMethodCalls(boolean) (9)
• java.lang.Thread.countStackFrames() (9)
• java.util.zip.Deflater.finalize() (10)
• java.util.zip.Inflater.finalize() (10)
• java.util.zip.ZipFile.finalize() (10)

Additional details about deprecations, including potential alternatives, may be found in the Deprecated API list of the API Specification. Migration away from deprecated APIs is strongly encouraged.

Compared to Java SE 11, this Specification does not add or propose to remove any further APIs.