Table of Contents
Java Language Specification Java SE 17 Edition Chapter 1 - Introduction
Return to Java 17 Language Spec Table of Contents, Java 17 Language Spec, Java Language Specifications, Language Specifications, Java bibliography, Java DevOps, Java, Java topics, Awesome Java, Java development tools
“ (JSR-392 JvLngSpc17 2021)
“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.” (JSR-392 JvLngSpc17 2021)
“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.” (JvLngSpc17 2021)
”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.“ (JvLngSpc17 2021)
“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).” (JvLngSpc17 2021)
”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.“ (JvLngSpc17 2021)
“The Java programming language is normally compiled to the bytecode instruction set and binary format defined in The Java Virtual Machine Specification, Java SE 17 Edition.” (JvLngSpc17 2021)
1
1.1
Organization of the Specification
1.1 Organization of the Specification
”Chapter 2 describes grammars and the notation used to present the lexical grammar and syntactic grammars for the language.“ (JvLngSpc17 2021)
”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.“ (JvLngSpc17 2021)
”Chapter 4 describes types, values, and variables. Types are subdivided into primitive types and reference types.“ (JvLngSpc17 2021)
“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, IEEE 754 floating-point numbers, a boolean type, and a Unicode character char type. Values of the primitive types do not share state.” (JvLngSpc17 2021)
”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). Classes and interfaces may be generic, that is, they may be parameterized by reference types. Parameterized types of such classes and interfaces may then be invoked with specific type arguments.“ (JvLngSpc17 2021)
”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 that is an instance of the named class or any subclass of that class. A variable of an interface type can hold a null reference or a reference to an instance of any class that implements the named 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.“ (JvLngSpc17 2021)
”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.“ (JvLngSpc17 2021)
There are no 2
Organization of the Specification
1.1
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, local interfaces, 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 the named class or any subclass of that class, allowing new classes to be used with existing methods, polymorphically.
Classes support concurrent programming with synchronized methods. Methods
declare the checked exception]]s that can arise from their execution, which allows 3
1.1
Organization of the Specification
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 re[[stricted]] kind of class, enum classes, supports the definition of small sets of values and their manipulation in a type safe manner. Unlike enumerations in other languages, enum constants are objects and may have their own methods.
Another re[[stricted]] kind of class, record classes, supports the compact expression of simple objects that serve as aggregates of values.
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.
Annotations are metadata that may be applied to declarations in a program, as well as to the uses of types in declarations and expressions. The form of an annotation is defined by an annotation interface, a specialized kind of interface. 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 exception]]s, run-time exceptions, and errors. The compiler ensures that checked exception]]s 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.
4
Organization of the Specification
1.1
Chapter 12 describes activities that occur during execution of a program. A program is normally stored as binary file]]s representing compiled classes and interfaces. These binary file]]s 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 classes and interfaces on other classes and interfaces that use the changed classes and interfaces but have not been recompiled. These considerations are of interest to developers of classes and interfaces 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
class or interface 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 statement]]s. 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 14 also describes patterns, which are used within statements (and expressions) to conditionally declare and initialize local variables.
Chapter 15 describes expressions. This document fully specifies the (apparent) order of [[evaluation of expression]]s, 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 5
1.2
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.
1.2 Example Programs
Most of the example programs given in the text are ready to be executed and are
public static void main(String[] args) {
for (int i = 0; i < args.length; i++)
System.out]].print(i == 0 ? args[i] : ” “ + args[i]);
}
}
On a machine with the Oracle JDK installed, this class, stored in the file Test.java, can be compiled and executed by giving the commands:
1.3 Notation
Throughout this specification we refer to classes and interfaces drawn from the Java SE Platform API. Whenever we refer to a class or interface (other than those declared in an example) using a single identifier N, the intended reference is to the class or interface named N in the package java.lang. We use the canonical name
(§6.7) for classes or interfaces from packages other than java.lang.
6
Relationship to Predefined Classes and Interfaces
1.4
Non-normative information, designed to clarify the specification, is given in smaller, indented text.
This is non-normative information. It provides intuition, rationale]], advice, examples, etc.
To shorten the description of some rules, especially those that systematic]]ally analyze the constructs of the Java programming language, the customary
abbreviation “iff” is used to mean “if and only if”.
The type system of the Java programming language occasionally relies on the notion of a substitution. The notation [ F1:= T1,…, Fn:= Tn] denotes substitution of Fi by Ti for 1 ≤ i ≤ n.
1.4 Relationship to Predefined Classes and Interfaces
As noted above, this specification often refers to classes and interfaces of the Java SE Platform API. In particular, some classes and interfaces have a special relationship with the Java programming language. Examples include classes such as Object, Class, ClassLoader, String, and Thread, and the classes and interfaces in the package java.lang.reflect, among others. This specification
constrains the behavior of such classes and interfaces, but does not provide a complete specification for them. The reader is referred to the Java SE Platform API documentation.
Consequently, this specification does not describe reflection in any detail.
Many linguistic constructs have analogs in the Core Reflection API
(java.lang.reflect) and the Language Model API (javax.lang.model), but
these are generally not discussed here. For example, when we list the ways in which an object can be created, we generally do not include the ways in which the Core Reflection API can accomplish this. Readers should be aware of these additional
mechanisms even though they are not mentioned in the text.
1.5 Preview Feature]]s
A preview feature]] is:
7
1.5
Preview Feature]]s
that is fully specified, fully implemented, and yet impermanent. It is available in implementations of a given release of the Java SE Platform to provoke developer
feedback]] based on real world use; this may lead to it becoming permanent in a future release of the Java SE Platform.
Implementations must disable, at both compile time and run time, the preview feature]]s defined by a given release of the Java SE Platform, unless the user indicates via the host system, at both compile time and run time, that preview feature]]s are to be enabled.
The preview feature]]s defined by a given release of the Java SE Platform are enumerated in the Java SE Platform Specification for that release. The preview feature]]s are specified as follows:
changes (“diffs”) to The Java Language Specification for that release. The specifications of preview language features are in[[corporated into The Java
Language Specification by reference, and made a part thereof, if and only if preview feature]]s are enabled at compile time.
Java SE 17 defines one preview language feature: Pattern Matching for switch.
The standalone document which specifies this preview feature]] is available at the Oracle web [[site which hosts The Java Language Specification: https://
docs.oracle.com/javase/specs/.
The rules for use of preview language features are as follows:
feature, causes a compile-time error.
– The reference appears in a declaration that is annotated to suppress preview
warnings (§9.6.4.5).
– The reference appears in an import declaration (§7.5).
When preview feature]]s are enabled, Java compilers are strongly en[[couraged to give a non-suppressible warning for every source code reference to a preview language feature.
Details of this warning are beyond the scoped of The Java Language Specification, but the intent should be to alert programmers to the possibility of code being affected by future changes to preview language features.
8
Feedback]]
1.6
Some preview APIs are described as reflective by the Java SE Platform Specification, principally in the java.lang.reflect, java.lang.invoke, and javax.lang.model packages. The rule for use of reflective preview APIs is as follows:
– The declaration where the reference appears is within the same module as the
declaration of the reflective preview API element.
– The reference appears in a declaration that is annotated to suppress preview
warnings.
– The reference appears in an import declaration.
All preview APIs not described as reflective in the Java SE Platform Specification are normal. The rules for use of normal preview APIs are as follows:
– The declaration where the reference appears is within the same module as the
declaration of the normal preview API element.
true:
– The declaration where the reference appears is within the same module as the
declaration of the normal preview API element.
– The reference appears in a declaration that is annotated to suppress preview
warnings.
– The reference appears in an import declaration.
1.6 Feedback]]
Readers are invited to report technical errors and ambiguities in The Java
Language Specification to jls-jvms-spec-comments@openjdk.java.net.
9
1.7
Questions concerning the behavior of javac]] (the reference compiler for the Java
programming language), and in particular its conformance to this specification, may be sent to compiler-dev@openjdk.java.net.
1.7 References
Apple [[Computer. Dylan Reference Manual. Apple [[Computer Inc., Cupertino, California.
Bobrow, Daniel G., Linda G. DeMichiel, Richard P. Gabriel, Sonya E. Keene, Gregor Kiczales, and David A. Moon. Common Lisp Object System Specification, X3J13 Document 88-002R, June 1988; appears as Chapter 28 of Steele, Guy. Common Lisp: The Language, 2nd ed. Digital Press, 1990, ISBN 1-55558-041-6, 770-864.
Ellis, Margaret A., and Bjarne Stroustrup. The Annotated C++ Reference Manual. Addison-Wesley, Reading, Massachusetts, 1990, reprinted with correction]]s October 1992, ISBN
0-201-51459-1.
Goldberg, Adele and Robson, David. Small[[talk-80: The Language. Addison-Wesley, Reading, Massachusetts, 1989, ISBN 0-201-13688-0.
Harbison, Samuel. Modula-3. Prentice Hall, Englewood Cliffs, New Jersey, 1992, ISBN
0-13-596396.
Hoare, C. A. R. Hints on Programming Language Design. Stanford University Computer Science Department Technical Report No. CS-73-403, December 1973. Reprinted in SIGACT/SIGPLAN Symposium on Principles of Programming Languages. Association for Computing Machinery, New York, October 1973.
IEEE. IEEE Standard for Floating-Point Arithmetic. IEEE Std 754-2019 (Revision of IEEE
754-2008). July 2019, ISBN 978-1-5044-5924-2.
Kernighan, Brian W., and Dennis M. Ritchie. The C Programming Language, 2nd ed. Prentice Hall, Englewood Cliffs, New Jersey, 1988, ISBN 0-13-110362-8.
Madsen, Ole Lehrmann, Birger Møller-Pedersen, and Kristen Nygaard. Object-Oriented Programming]] in the Beta Programming Language. Addison-Wesley, Reading, Massachusetts, 1993, ISBN 0-201-62430-3.
Mitchell, James G., William Maybury, and Richard Sweet. The Mesa Programming Language, Version 5.0. Xerox PARC]], Palo Alto, California, CSL 79-3, April 1979.
Stroustrup, Bjarne. The C++ Programming Language, 2nd ed. Addison-Wesley, Reading, Massachusetts, 1991, reprinted with correction]]s January 1994, ISBN 0-201-53992-6.
Unicode Consortium, The. The Unicode Standard, Version 13.0. Mountain]] View, California, 2020, ISBN 978-1-936213-26-9.
10
Fair Use Sources
Java: Java Fundamentals, Java Inventor - Java Language Designer: James Gosling of Sun Microsystems, Java Docs, JDK, JVM, JRE, Java Keywords, JDK 17 API Specification, java.base, Java Built-In Data Types, Java Data Structures - Java Algorithms, Java Syntax, Java OOP - Java Design Patterns, Java Installation, Java Containerization, Java Configuration, Java Compiler, Java Transpiler, Java IDEs (IntelliJ - Eclipse - NetBeans), Java Development Tools, Java Linter, JetBrains, Java Testing (JUnit, Hamcrest, Mockito), Java on Android, Java on Windows, Java on macOS, Java on Linux, Java DevOps - Java SRE, Java Data Science - Java DataOps, Java Machine Learning, Java Deep Learning, Functional Java, Java Concurrency, Java History,
Java Bibliography (Effective Java, Head First Java, Java - A Beginner's Guide by Herbert Schildt, Java Concurrency in Practice, Clean Code by Robert C. Martin, Java - The Complete Reference by Herbert Schildt, Java Performance by Scott Oaks, Thinking in Java, Java - How to Program by Paul Deitel, Modern Java in Action, Java Generics and Collections by Maurice Naftalin, Spring in Action, Java Network Programming by Elliotte Rusty Harold, Functional Programming in Java by Pierre-Yves Saumont, Well-Grounded Java Developer, Second Edition, Java Module System by Nicolai Parlog
), Manning Java Series, Java Glossary, Java Topics, Java Courses, Java Security - Java DevSecOps, Java Standard Library, Java Libraries, Java Frameworks, Java Research, Java GitHub, Written in Java, Java Popularity, Java Awesome List, Java Versions. (navbar_java and navbar_java_detailed - see also navbar_jvm, navbar_java_concurrency, navbar_java_standard_library, navbar_java_libraries, navbar_java_navbars)
© 1994 - 2024 Cloud Monk Losang Jinpa or Fair Use. Disclaimers
SYI LU SENG E MU CHYWE YE. NAN. WEI LA YE. WEI LA YE. SA WA HE.