Chapter 1. Introduction
The Java programming language is a general-purpose, concurrent, class-based, object-oriented
language. It is designed to be simple enough that many programmers can achieve fluency in the
language. The Java programming language is related to C and C++ but is organized rather
differently, with a number of aspects of C and C++ omitted and a few ideas from other
languages included. It is intended to be a production language, not a research language,
and so, as C. A. R. Hoare suggested in his classic paper on language design, the design
has avoided including new and untested features.
The Java programming language is strongly and statically typed. This specification
clearly distinguishes between the compile-time errors that can and must be detected at
compile time, and those that occur at run time. Compile time normally consists of translating
programs into a machine-independent byte code representation. Run-time activities include loading
and linking of the classes needed to execute a program, optional machine code generation and
dynamic optimization of the program, and actual program execution.
The Java programming language is a relatively high-level language, in that details of the
machine representation are not available through the language. It includes automatic storage
management, typically using a garbage collector, to avoid the safety problems of explicit
deallocation (as in C's free or C++'s delete). High-performance garbage-collected implementations
can have bounded pauses to support systems programming and real-time applications. The language
does not include any unsafe constructs, such as array accesses without index checking,
since such unsafe constructs would cause a program to behave in an unspecified way.
The Java programming language is normally compiled to the bytecode instruction set and binary
format defined in The Java Virtual Machine Specification, Java SE 14 Edition.
1.1. Organization of the Specification
Chapter 2 describes grammars and the notation used to present the lexical and syntactic grammars
for the language.
Chapter 3 describes the lexical structure of the Java programming language, which is based on C
and C++. The language is written in the Unicode character set. It supports the writing of Unicode
characters on systems that support only ASCII.
Chapter 4 describes types, values, and variables. Types are subdivided into primitive types and
reference types.
The primitive types are defined to be the same on all machines and in all implementations, and are
various sizes of two's-complement integers, single- and double-precision IEEE 754 standard
floating-point numbers, a boolean type, and a Unicode character char type. Values of the primitive
types do not share state.
Reference types are the class types, the interface types, and the array types. The reference types
are implemented by dynamically created objects that are either instances of classes or arrays. Many
references to each object can exist. All objects (including arrays) support the methods of the
class Object, which is the (single) root of the class hierarchy. A predefined String class supports
Unicode character strings. Classes exist for wrapping primitive values inside of objects.
In many cases, wrapping and unwrapping is performed automatically by the compiler (in which case,
wrapping is called boxing, and unwrapping is called unboxing). Class and interface declarations may
be generic, that is, they may be parameterized by other reference types. Such declarations may then
be invoked with specific type arguments.
Variables are typed storage locations. A variable of a primitive type holds a value of that exact
primitive type. A variable of a class type can hold a null reference or a reference to an object
whose type is that class type or any subclass of that class type. A variable of an interface type
can hold a null reference or a reference to an instance of any class that implements the interface.
A variable of an array type can hold a null reference or a reference to an array. A variable of
class type Object can hold a null reference or a reference to any object, whether class instance or
array.
Chapter 5 describes conversions and numeric promotions. Conversions change the compile-time type
and, sometimes, the value of an expression. These conversions include the boxing and unboxing
conversions between primitive types and reference types. Numeric promotions are used to convert the
operands of a numeric operator to a common type where an operation can be performed. There are no
loopholes in the language; casts on reference types are checked at run time to ensure type safety.
Chapter 6 describes declarations and names, and how to determine what names mean (that is, which
declaration a name denotes). The Java programming language does not require classes and interfaces,
or their members, to be declared before they are used. Declaration order is significant only for
local variables, local classes, and the order of field initializers in a class or interface.
Recommended naming conventions that make for more readable programs are described here.
Chapter 7 describes the structure of a program, which is organized into packages.
The members of a package are classes, interfaces, and subpackages. Packages, and consequently
their members, have names in a hierarchical name space; the Internet domain name system can usually
be used to form unique package names. Compilation units contain declarations of the classes and
interfaces that are members of a given package, and may import classes and interfaces from other
packages to give them short names.
Packages may be grouped into modules that serve as building blocks in the construction of very
large programs. The declaration of a module specifies which other modules (and thus packages, and
thus classes and interfaces) are required in order to compile and run code in its own packages.
The Java programming language supports limitations on external access to the members of packages,
classes, and interfaces. The members of a package may be accessible solely by other members in the
same package, or by members in other packages of the same module, or by members of packages in
different modules. Similar constraints apply to the members of classes and interfaces.
Chapter 8 describes classes. The members of classes are classes, interfaces, fields (variables) and
methods. Class variables exist once per class. Class methods operate without reference to a
specific object. Instance variables are dynamically created in objects that are instances of
classes. Instance methods are invoked on instances of classes; such instances become the current
object this during their execution, supporting the object-oriented programming style.
Classes support single inheritance, in which each class has a single superclass. Each class
inherits members from its superclass, and ultimately from the class Object. Variables of a class
type can reference an instance of that class or of any subclass of that class, allowing new types
to be used with existing methods, polymorphically.
Classes support concurrent programming with synchronized methods. Methods declare the checked
exceptions that can arise from their execution, which allows compile-time checking to ensure that
exceptional conditions are handled. Objects can declare a finalize method that will be invoked
before the objects are discarded by the garbage collector, allowing the objects to clean up their
state.
For simplicity, the language has neither declaration "headers" separate from the implementation
of a class nor separate type and class hierarchies.
A special form of classes, enums, support the definition of small sets of values and their
manipulation in a type safe manner. Unlike enumerations in other languages, enums are objects
and may have their own methods.
Chapter 9 describes interfaces. The members of interfaces are classes, interfaces, constant
fields, and methods. Classes that are otherwise unrelated can implement the same interface. A
variable of an interface type can contain a reference to any object that implements the interface.
Classes and interfaces support multiple inheritance from interfaces. A class that implements one
or more interfaces may inherit instance methods from both its superclass and its superinterfaces.
Annotation types are specialized interfaces used to annotate declarations. Such annotations are
not permitted to affect the semantics of programs in the Java programming language in any way.
However, they provide useful input to various tools.
Chapter 10 describes arrays. Array accesses include bounds checking. Arrays are dynamically created
objects and may be assigned to variables of type Object. The language supports arrays of arrays,
rather than multidimensional arrays.
Chapter 11 describes exceptions, which are nonresuming and fully integrated with the language
semantics and concurrency mechanisms. There are three kinds of exceptions: checked exceptions,
run-time exceptions, and errors. The compiler ensures that checked exceptions are properly
handled by requiring that a method or constructor can result in a checked exception only if
the method or constructor declares it. This provides compile-time checking that exception handlers
exist, and aids programming in the large. Most user-defined exceptions should be checked
exceptions. Invalid operations in the program detected by the Java Virtual Machine result in
run-time exceptions, such as NullPointerException. Errors result from failures detected by the
Java Virtual Machine, such as OutOfMemoryError. Most simple programs do not try to handle errors.
Chapter 12 describes activities that occur during execution of a program. A program is normally
stored as binary files representing compiled classes and interfaces. These binary files can be
loaded into a Java Virtual Machine, linked to other classes and interfaces, and initialized.
After initialization, class methods and class variables may be used. Some classes may be
instantiated to create new objects of the class type. Objects that are class instances also
contain an instance of each superclass of the class, and object creation involves recursive
creation of these superclass instances.
When an object is no longer referenced, it may be reclaimed by the garbage collector. If an
object declares a finalizer, the finalizer is executed before the object is reclaimed to give
the object a last chance to clean up resources that would not otherwise be released. When a
class is no longer needed, it may be unloaded.
Chapter 13 describes binary compatibility, specifying the impact of changes to types on other
types that use the changed types but have not been recompiled. These considerations are of
interest to developers of types that are to be widely distributed, in a continuing series of
versions, often through the Internet. Good program development environments automatically
recompile dependent code whenever a type is changed, so most programmers need not be concerned
about these details.
Chapter 14 describes blocks and statements, which are based on C and C++. The language has no
goto statement, but includes labeled break and continue statements. Unlike C, the Java
programming language requires boolean (or Boolean) expressions in control-flow statements,
and does not convert types to boolean implicitly (except through unboxing), in the hope of
catching more errors at compile time. A synchronized statement provides basic object-level
monitor locking. A try statement can include catch and finally clauses to protect against
non-local control transfers.
Chapter 15 describes expressions. This document fully specifies the (apparent) order of
evaluation of expressions, for increased determinism and portability. Overloaded methods and
constructors are resolved at compile time by picking the most specific method or constructor
from those which are applicable.
Chapter 16 describes the precise way in which the language ensures that local variables are
definitely set before use. While all other variables are automatically initialized to a
default value, the Java programming language does not automatically initialize local variables
in order to avoid masking programming errors.
Chapter 17 describes the semantics of threads and locks, which are based on the monitor-based
concurrency originally introduced with the Mesa programming language. The Java programming
language specifies a memory model for shared-memory multiprocessors that supports high-performance
implementations.
Chapter 18 describes a variety of type inference algorithms used to test applicability of
generic methods and to infer types in a generic method invocation.
Chapter 19 presents a syntactic grammar for the language.