The Java Language Specification. Java SE 8 Edition

Transcription

1

2 The Java Language Specification Java SE 8 Edition

3 This page intentionally left blank

4 The Java Language Specification Java SE 8 Edition James Gosling Bill Joy Guy Steele Gilad Bracha Alex Buckley Upper Saddle River, NJ Boston Indianapolis San Francisco New York Toronto Montreal London Munich Paris Madrid Capetown Sydney Tokyo Singapore Mexico City

5 Copyright 1997, 2014, Oracle and/or its affiliates. All rights reserved. 500 Oracle Parkway, Redwood City, California 94065, U.S.A. Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in this book, and the publisher was aware of a trademark claim, the designations have been printed with initial capital letters or in all capitals. Oracle and Java are registered trademarks of Oracle and/or its affiliates. Other names may be trademarks of their respective owners. The authors and publisher have taken care in the preparation of this book, but make no expressed or implied warranty of any kind and assume no responsibility for errors or omissions. No liability is assumed for incidental or consequential damages in connection with or arising out of the use of the information or programs contained herein. This document is provided for information purposes only and the contents hereof are subject to change without notice. This document is not warranted to be error-free, nor subject to any other warranties or conditions, whether expressed orally or implied in law, including implied warranties and conditions of merchantability or fitness for a particular purpose. We specifically disclaim any liability with respect to this document and no contractual obligations are formed either directly or indirectly by this document, except as specified in the Limited License Grant herein at Appendix A. This document is subject to the Limited License Grant included herein as Appendix A, and may otherwise not be reproduced or transmitted in any form or by any means, electronic or mechanical, for any purpose, without our prior written permission. The publisher offers excellent discounts on this book when ordered in quantity for bulk purchases or special sales, which may include electronic versions and/or custom covers and content particular to your business, training goals, marketing focus, and branding interests. For more information, please contact U.S. Corporate and Government Sales, (800) , corpsales@pearsontechgroup.com. For sales outside the United States, please contact International Sales, international@pearson.com. Visit us on the Web: informit.com/aw Library of Congress Control Number: ISBN-13: ISBN-10: X Printed in the United States of America. This publication is protected by copyright, and permission must be obtained from the publisher prior to any prohibited reproduction, storage in a retrieval system, or transmission in any form or by any means, electronic, mechanical, photocopying, recording, or likewise. To obtain permission to use material from this work, please submit a written request to Pearson Education, Inc., Permissions Department, One Lake Street, Upper Saddle River, New Jersey 07458, or you may fax your request to (201) The Specification provided herein is provided to you only under the Limited License Grant included herein as Appendix A. Please see Appendix A. Text printed in the United States on recycled paper at Edwards Brothers Malloy in Ann Arbor, Michigan. First printing, May 2014.

6 To Maurizio, with deepest thanks.

7 This page intentionally left blank

8 Table of Contents Preface to the Java SE 8 Edition xxi 1 Introduction Organization of the Specification Example Programs Notation Relationship to Predefined Classes and Interfaces Feedback References 7 2 Grammars Context-Free Grammars The Lexical Grammar The Syntactic Grammar Grammar Notation 10 3 Lexical Structure Unicode Lexical Translations Unicode Escapes Line Terminators Input Elements and Tokens White Space Comments Identifiers Keywords Literals Integer Literals Floating-Point Literals Boolean Literals Character Literals String Literals Escape Sequences for Character and String Literals The Null Literal Separators Operators 38 vii

9 The Java Language Specification 4 Types, Values, and Variables The Kinds of Types and Values Primitive Types and Values Integral Types and Values Integer Operations Floating-Point Types, Formats, and Values Floating-Point Operations The boolean Type and boolean Values Reference Types and Values Objects The Class Object The Class String When Reference Types Are the Same Type Variables Parameterized Types Type Arguments of Parameterized Types Members and Constructors of Parameterized Types Type Erasure Reifiable Types Raw Types Intersection Types Subtyping Subtyping among Primitive Types Subtyping among Class and Interface Types Subtyping among Array Types Least Upper Bound Where Types Are Used Variables Variables of Primitive Type Variables of Reference Type Kinds of Variables final Variables Initial Values of Variables Types, Classes, and Interfaces 88 5 Conversions and Contexts Kinds of Conversion Identity Conversion Widening Primitive Conversion Narrowing Primitive Conversion Widening and Narrowing Primitive Conversion Widening Reference Conversion Narrowing Reference Conversion Boxing Conversion Unboxing Conversion Unchecked Conversion Capture Conversion 103 viii

10 The Java Language Specification String Conversion Forbidden Conversions Value Set Conversion Assignment Contexts Invocation Contexts String Contexts Casting Contexts Reference Type Casting Checked Casts and Unchecked Casts Checked Casts at Run Time Numeric Contexts Unary Numeric Promotion Binary Numeric Promotion Names Declarations Names and Identifiers Scope of a Declaration Shadowing and Obscuring Shadowing Obscuring Determining the Meaning of a Name Syntactic Classification of a Name According to Context Reclassification of Contextually Ambiguous Names Meaning of Package Names Simple Package Names Qualified Package Names Meaning of PackageOrTypeNames Simple PackageOrTypeNames Qualified PackageOrTypeNames Meaning of Type Names Simple Type Names Qualified Type Names Meaning of Expression Names Simple Expression Names Qualified Expression Names Meaning of Method Names Simple Method Names Access Control Determining Accessibility Details on protected Access Access to a protected Member Qualified Access to a protected Constructor Fully Qualified Names and Canonical Names Packages Package Members 173 ix

11 The Java Language Specification 7.2 Host Support for Packages Compilation Units Package Declarations Named Packages Unnamed Packages Observability of a Package Import Declarations Single-Type-Import Declarations Type-Import-on-Demand Declarations Single-Static-Import Declarations Static-Import-on-Demand Declarations Top Level Type Declarations Classes Class Declarations Class Modifiers abstract Classes final Classes strictfp Classes Generic Classes and Type Parameters Inner Classes and Enclosing Instances Superclasses and Subclasses Superinterfaces Class Body and Member Declarations Class Members Field Declarations Field Modifiers static Fields final Fields transient Fields volatile Fields Field Initialization Forward References During Field Initialization Method Declarations Formal Parameters Method Signature Method Modifiers abstract Methods static Methods final Methods native Methods strictfp Methods synchronized Methods Generic Methods Method Result Method Throws Method Body 240 x

12 The Java Language Specification Inheritance, Overriding, and Hiding Overriding (by Instance Methods) Hiding (by Class Methods) Requirements in Overriding and Hiding Inheriting Methods with Override-Equivalent Signatures Overloading Member Type Declarations Static Member Type Declarations Instance Initializers Static Initializers Constructor Declarations Formal Parameters Constructor Signature Constructor Modifiers Generic Constructors Constructor Throws The Type of a Constructor Constructor Body Explicit Constructor Invocations Constructor Overloading Default Constructor Preventing Instantiation of a Class Enum Types Enum Constants Enum Body Declarations Enum Members Interfaces Interface Declarations Interface Modifiers abstract Interfaces strictfp Interfaces Generic Interfaces and Type Parameters Superinterfaces and Subinterfaces Interface Body and Member Declarations Interface Members Field (Constant) Declarations Initialization of Fields in Interfaces Method Declarations Inheritance and Overriding Overriding (by Instance Methods) Requirements in Overriding Inheriting Methods with Override-Equivalent Signatures Overloading Interface Method Body 291 xi

13 The Java Language Specification 9.5 Member Type Declarations Annotation Types Annotation Type Elements Defaults for Annotation Type Elements Repeatable Annotation Types Predefined Annotation Types Annotations Normal Annotations Marker Annotations Single-Element Annotations Where Annotations May Appear Multiple Annotations of the Same Type Functional Interfaces Function Types Arrays Array Types Array Variables Array Creation Array Access Array Store Exception Array Initializers Array Members Class Objects for Arrays An Array of Characters Is Not a String Exceptions The Kinds and Causes of Exceptions The Kinds of Exceptions The Causes of Exceptions Asynchronous Exceptions Compile-Time Checking of Exceptions Exception Analysis of Expressions Exception Analysis of Statements Exception Checking Run-Time Handling of an Exception 349 xii

14 The Java Language Specification 12 Execution Java Virtual Machine Startup Load the Class Test Link Test: Verify, Prepare, (Optionally) Resolve Initialize Test: Execute Initializers Invoke Test.main Loading of Classes and Interfaces The Loading Process Linking of Classes and Interfaces Verification of the Binary Representation Preparation of a Class or Interface Type Resolution of Symbolic References Initialization of Classes and Interfaces When Initialization Occurs Detailed Initialization Procedure Creation of New Class Instances Finalization of Class Instances Implementing Finalization Interaction with the Memory Model Unloading of Classes and Interfaces Program Exit Binary Compatibility The Form of a Binary What Binary Compatibility Is and Is Not Evolution of Packages Evolution of Classes abstract Classes final Classes public Classes Superclasses and Superinterfaces Class Type Parameters Class Body and Member Declarations Access to Members and Constructors Field Declarations final Fields and static Constant Variables static Fields transient Fields Method and Constructor Declarations Method and Constructor Type Parameters Method and Constructor Formal Parameters Method Result Type abstract Methods final Methods native Methods static Methods synchronized Methods 398 xiii

15 The Java Language Specification Method and Constructor Throws Method and Constructor Body Method and Constructor Overloading Method Overriding Static Initializers Evolution of Enums Evolution of Interfaces public Interfaces Superinterfaces Interface Members Interface Type Parameters Field Declarations Interface Method Declarations Evolution of Annotation Types Blocks and Statements Normal and Abrupt Completion of Statements Blocks Local Class Declarations Local Variable Declaration Statements Local Variable Declarators and Types Execution of Local Variable Declarations Statements The Empty Statement Labeled Statements Expression Statements The if Statement The if-then Statement The if-then-else Statement The assert Statement The switch Statement The while Statement Abrupt Completion of while Statement The do Statement Abrupt Completion of do Statement The for Statement The basic for Statement Initialization of for Statement Iteration of for Statement Abrupt Completion of for Statement The enhanced for statement The break Statement The continue Statement The return Statement The throw Statement The synchronized Statement The try statement 440 xiv

16 The Java Language Specification Execution of try-catch Execution of try-finally and try-catch-finally try-with-resources Basic try-with-resources Extended try-with-resources Unreachable Statements Expressions Evaluation, Denotation, and Result Forms of Expressions Type of an Expression FP-strict Expressions Expressions and Run-Time Checks Normal and Abrupt Completion of Evaluation Evaluation Order Evaluate Left-Hand Operand First Evaluate Operands before Operation Evaluation Respects Parentheses and Precedence Argument Lists are Evaluated Left-to-Right Evaluation Order for Other Expressions Primary Expressions Lexical Literals Class Literals this Qualified this Parenthesized Expressions Class Instance Creation Expressions Determining the Class being Instantiated Determining Enclosing Instances Choosing the Constructor and its Arguments Run-Time Evaluation of Class Instance Creation Expressions Anonymous Class Declarations Anonymous Constructors Array Creation and Access Expressions Array Creation Expressions Run-Time Evaluation of Array Creation Expressions Array Access Expressions Run-Time Evaluation of Array Access Expressions Field Access Expressions Field Access Using a Primary Accessing Superclass Members using super Method Invocation Expressions Compile-Time Step 1: Determine Class or Interface to Search Compile-Time Step 2: Determine Method Signature Identify Potentially Applicable Methods 509 xv

17 The Java Language Specification Phase 1: Identify Matching Arity Methods Applicable by Strict Invocation Phase 2: Identify Matching Arity Methods Applicable by Loose Invocation Phase 3: Identify Methods Applicable by Variable Arity Invocation Choosing the Most Specific Method Method Invocation Type Compile-Time Step 3: Is the Chosen Method Appropriate? Run-Time Evaluation of Method Invocation Compute Target Reference (If Necessary) Evaluate Arguments Check Accessibility of Type and Method Locate Method to Invoke Create Frame, Synchronize, Transfer Control Method Reference Expressions Compile-Time Declaration of a Method Reference Type of a Method Reference Run-Time Evaluation of Method References Postfix Expressions Expression Names Postfix Increment Operator Postfix Decrement Operator Unary Operators Prefix Increment Operator Prefix Decrement Operator Unary Plus Operator Unary Minus Operator Bitwise Complement Operator ~ Logical Complement Operator! Cast Expressions Multiplicative Operators Multiplication Operator * Division Operator / Remainder Operator % Additive Operators String Concatenation Operator Additive Operators (+ and -) for Numeric Types Shift Operators Relational Operators Numerical Comparison Operators <, <=, >, and >= Type Comparison Operator instanceof Equality Operators Numerical Equality Operators == and!= Boolean Equality Operators == and!= Reference Equality Operators == and!= Bitwise and Logical Operators Integer Bitwise Operators &, ^, and 568 xvi

18 The Java Language Specification Boolean Logical Operators &, ^, and Conditional-And Operator && Conditional-Or Operator Conditional Operator? : Boolean Conditional Expressions Numeric Conditional Expressions Reference Conditional Expressions Assignment Operators Simple Assignment Operator = Compound Assignment Operators Lambda Expressions Lambda Parameters Lambda Body Type of a Lambda Expression Run-Time Evaluation of Lambda Expressions Constant Expressions Definite Assignment Definite Assignment and Expressions Boolean Constant Expressions Conditional-And Operator && Conditional-Or Operator Logical Complement Operator! Conditional Operator? : Conditional Operator? : Other Expressions of Type boolean Assignment Expressions Operators ++ and Other Expressions Definite Assignment and Statements Empty Statements Blocks Local Class Declaration Statements Local Variable Declaration Statements Labeled Statements Expression Statements if Statements assert Statements switch Statements while Statements do Statements for Statements Initialization Part of for Statement Incrementation Part of for Statement break, continue, return, and throw Statements synchronized Statements try Statements 624 xvii

19 The Java Language Specification 16.3 Definite Assignment and Parameters Definite Assignment and Array Initializers Definite Assignment and Enum Constants Definite Assignment and Anonymous Classes Definite Assignment and Member Types Definite Assignment and Static Initializers Definite Assignment, Constructors, and Instance Initializers Threads and Locks Synchronization Wait Sets and Notification Wait Notification Interruptions Interactions of Waits, Notification, and Interruption Sleep and Yield Memory Model Shared Variables Actions Programs and Program Order Synchronization Order Happens-before Order Executions Well-Formed Executions Executions and Causality Requirements Observable Behavior and Nonterminating Executions final Field Semantics Semantics of final Fields Reading final Fields During Construction Subsequent Modification of final Fields Write-Protected Fields Word Tearing Non-Atomic Treatment of double and long Type Inference Concepts and Notation Inference Variables Constraint Formulas Bounds Reduction Expression Compatibility Constraints Type Compatibility Constraints Subtyping Constraints Type Equality Constraints Checked Exception Constraints Incorporation Complementary Pairs of Bounds 674 xviii

20 The Java Language Specification Bounds Involving Capture Conversion Resolution Uses of Inference Invocation Applicability Inference Invocation Type Inference Functional Interface Parameterization Inference More Specific Method Inference Syntax 689 Index 715 A Limited License Grant 755 xix

21 This page intentionally left blank

22 Preface to the Java SE 8 Edition IN 1996, James Gosling, Bill Joy, and Guy Steele wrote for the First Edition of The Java Language Specification: "We believe that the Java programming language is a mature language, ready for widespread use. Nevertheless, we expect some evolution of the language in the years to come. We intend to manage this evolution in a way that is completely compatible with existing applications." Java SE 8 represents the single largest evolution of the Java language in its history. A relatively small number of features - lambda expressions, method references, and functional interfaces - combine to offer a programming model that fuses the objectoriented and functional styles. Under the leadership of Brian Goetz, this fusion has been accomplished in a way that encourages best practices - immutability, statelessness, compositionality - while preserving "the feel of Java" - readability, simplicity, universality. Crucially, the libraries of the Java SE platform have co-evolved with the Java language. This means that using lambda expressions and method references to represent behavior - for example, an operation to be applied to each element in a list - is productive and performant "out of the box". In a similar fashion, the Java Virtual Machine has co-evolved with the Java language to ensure that default methods support library evolution as consistently as possible across compile time and run time, given the constraints of separate compilation. Initiatives to add first-class functions to the Java language have been around since the 1990s. The BGGA and CICE proposals circa 2007 brought new energy to the topic, while the creation of Project Lambda in OpenJDK circa 2009 attracted unprecedented levels of interest. The addition of method handles to the JVM in Java SE 7 opened the door to new implementation techniques while retaining "write once, run anywhere." In time, language changes were overseen by JSR 335, Lambda Expressions for the Java Programming Language, whose Expert Group consisted of Joshua Bloch, Kevin Bourrillion, Andrey Breslav, Rémi Forax, Dan Heidinga, Doug Lea, Bob Lee, David Lloyd, Sam Pullara, Srikanth Sankaran, and Vladimir Zakharov. Programming language design typically involves grappling with degrees of complexity utterly hidden from the language's users. (For this reason, it is often compared to an iceberg: 90% of it is invisible.) In JSR 335, the greatest complexity xxi

23 PREFACE TO THE JAVA SE 8 EDITION lurked in the interaction of implicitly typed lambda expressions with overload resolution. In this and many other areas, Dan Smith at Oracle did an outstanding job of thoroughly specifying the desired behavior. His words are to be found throughout this specification, including an entirely new chapter on type inference. Another initiative in Java SE 8 has been to enhance the utility of annotations, one of the most popular features of the Java language. First, the Java grammar has been extended to allow annotations on types in many language constructs, forming the basis for novel static analysis tools such as the Checker Framework. This feature was specified by JSR 308, Annotations on Java Types, led by Michael Ernst with an Expert Group of myself, Doug Lea, and Srikanth Sankaran. The changes involved in this specification were wide-ranging, and the unstinting efforts of Michael Ernst and Werner Dietl over many years are warmly recognized. Second, annotations may be "repeated" on a language construct, to the great benefit of APIs that model domain-specific configuration with annotation types. Michael Keith and Bill Shannon in Java EE initiated and guided this feature. Many colleagues in the Java Platform Group at Oracle have provided valuable support to this specification: Leonid Arbouzov, Mandy Chung, Joe Darcy, Robert Field, Joel Franck, Sonali Goel, Jon Gibbons, Jeannette Hung, Stuart Marks, Eric McCorkle, Matherey Nunez, Mark Reinhold, Vicente Romero, John Rose, Georges Saab, Steve Sides, Bernard Traversat, and Michel Trudeau. Perhaps the greatest acknowledgement must go to the compiler engineers who turn the specification into real software. Maurizio Cimadamore at Oracle worked heroically from the earliest days on the design of lambda expressions and their implementation in javac. Support for Java SE 8 features in Eclipse was contributed by Jayaprakash Arthanareeswaran, Shankha Banerjee, Anirban Chakraborty, Andrew Clement, Stephan Herrmann, Markus Keller, Jesper Møller, Manoj Palat, Srikanth Sankaran, and Olivier Thomann; and in IntelliJ by Anna Kozlova, Alexey Kudravtsev, and Roman Shevchenko. They deserve the thanks of the entire Java community. Java SE 8 is a renaissance for the Java language. While some search for the "next great language", we believe that programming in Java is more exciting and productive than ever. We hope that it continues to wear well for you. Alex Buckley Santa Clara, California March, 2014 xxii

24 CHAPTER1 Introduction THE Java programming language is a general-purpose, concurrent, classbased, 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 8 Edition. 1

25 1 INTRODUCTION 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 2

26 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 (denote). The language does not require types or their members to be declared before they are used. Declaration order is significant only for local variables, local classes, and the order of initializers of fields in a class or interface. The Java programming language provides control over the scope of names and supports limitations on external access to members of packages, classes, and interfaces. This helps in writing large programs by distinguishing the implementation of a type from its users and those who extend it. 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 similar to the modules of Modula. The members of a package are classes, interfaces, and subpackages. Packages are divided into compilation units. Compilation units contain type declarations and can import types from other packages to give them short names. Packages have names in a hierarchical name space, and the Internet domain name system can usually be used to form unique package names. 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 implementation inheritance, in which the implementation of each class is derived from that of a single 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. 3

27 1 INTRODUCTION 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 interface types, which declare a set of abstract methods, member types, and constants. Classes that are otherwise unrelated can implement the same interface type. A variable of an interface type can contain a reference to any object that implements the interface. Multiple interface inheritance is supported. 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 4

28 Organization of the Specification 1.1 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 sharedmemory 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. 5

29 1 INTRODUCTION 1.2 Example Programs Most of the example programs given in the text are ready to be executed and are similar in form to: class Test { public static void main(string[] args) { for (int i = 0; i < args.length; i++) System.out.print(i == 0? args[i] : " " + args[i]); System.out.println(); } } 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: javac Test.java java Test Hello, world. producing the output: Hello, world. 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. 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. The type system of the Java programming language occasionally relies on the notion of a substitution. The notation [F 1 :=T 1,...,F n :=T n ] denotes substitution of F i by T i for 1 i n. 6

30 Relationship to Predefined Classes and Interfaces Relationship to Predefined Classes and Interfaces As noted above, this specification often refers to classes of the Java SE platform API. In particular, some classes have a special relationship with the Java programming language. Examples include classes such as Object, Class, ClassLoader, String, Thread, and the classes and interfaces in 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 Feedback Readers may send feedback about errors, omissions, and ambiguities in The Java Language Specification to jls-comments_ww@oracle.com. 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.6 References Apple Computer. Dylan Reference Manual. Apple Computer Inc., Cupertino, California. September 29, 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 R, June 1988; appears as Chapter 28 of Steele, Guy. Common Lisp: The Language, 2nd ed. Digital Press, 1990, ISBN , Ellis, Margaret A., and Bjarne Stroustrup. The Annotated C++ Reference Manual. Addison- Wesley, Reading, Massachusetts, 1990, reprinted with corrections October 1992, ISBN

31 1 INTRODUCTION Goldberg, Adele and Robson, David. Smalltalk-80: The Language. Addison-Wesley, Reading, Massachusetts, 1989, ISBN Harbison, Samuel. Modula-3. Prentice Hall, Englewood Cliffs, New Jersey, 1992, ISBN Hoare, C. A. R. Hints on Programming Language Design. Stanford University Computer Science Department Technical Report No. CS , December Reprinted in SIGACT/SIGPLAN Symposium on Principles of Programming Languages. Association for Computing Machinery, New York, October IEEE Standard for Binary Floating-Point Arithmetic. ANSI/IEEE Std Available from Global Engineering Documents, 15 Inverness Way East, Englewood, Colorado USA; Kernighan, Brian W., and Dennis M. Ritchie. The C Programming Language, 2nd ed. Prentice Hall, Englewood Cliffs, New Jersey, 1988, ISBN Madsen, Ole Lehrmann, Birger Møller-Pedersen, and Kristen Nygaard. Object-Oriented Programming in the Beta Programming Language. Addison-Wesley, Reading, Massachusetts, 1993, ISBN Mitchell, James G., William Maybury, and Richard Sweet. The Mesa Programming Language, Version 5.0. Xerox PARC, Palo Alto, California, CSL 79-3, April Stroustrup, Bjarne. The C++ Progamming Language, 2nd ed. Addison-Wesley, Reading, Massachusetts, 1991, reprinted with corrections January 1994, ISBN Unicode Consortium, The. The Unicode Standard, Version Mountain View, CA, 2011, ISBN

32 Index Symbols = operator, 582 assignment contexts, 109 expressions and run-time checks, 463, 464 normal and abrupt completion of evaluation, 465, repeatable annotation types, 303 repeatable annotation types, 307 formal parameters, 305 checked casts and unchecked casts, 121 formal parameters, 228 requirements in overriding and hiding, 246 unchecked conversion, 302 multiple annotations of the same type, 318 repeatable annotation types, 298 where annotations may appear, 313 A abrupt completion of do statement, 425 do statement, 425 abrupt completion of for statement, 428 iteration of for statement, 428 abrupt completion of while statement, 424 while statement, 423 abstract classes, 192, 383 abstract methods, 232 anonymous class declarations, 485 array creation expressions, 487 final classes, 194 superinterfaces, 204 abstract interfaces, 279 abstract methods, 232, 396 abstract classes, 192 method body, 240 method declarations, 286 access control, 161 accessing superclass members using super, 498 class literals, 474 class modifiers, 191 constructor declarations, 256 default constructor, 265 enum body declarations, 269 explicit constructor invocations, 262 field access using a primary, 495 identify potentially applicable methods, 509 import declarations, 180 interface modifiers, 278 local class declarations, 407 member type declarations, 254 method declarations, 286 normal annotations, 309 objects, 54 qualified expression names, 158, 158,

33 INDEX qualified type names, 156, 156 reference types and values, 53 requirements in overriding and hiding, 247 single-static-import declarations, 184 single-type-import declarations, 181 static-import-on-demand declarations, 184 superclasses and subclasses, 200 superinterfaces, 202 superinterfaces and subinterfaces, 280 type-import-on-demand declarations, 183 access to a protected member, 167 access to members and constructors, 387 accessing superclass members using super, 497 declarations, 132 field declarations, 213 field initialization, 221, 222 initialization of fields in interfaces, 285 instance initializers, 255 static methods, 234 to context, 150 actions, 640 synchronization order, 642 additive operators, 556 constant expressions, 605 integer operations, 43 additive operators (+ and -) for numeric types, 559 binary numeric promotion, 126 floating-point operations, 48 an array of characters is not a String, 339 annotation type elements, 303 annotation types, 293 declarations, 130, 131, 131 marker annotations, 311 normal annotations, 309 single-element annotations, 312 to context, 150 where types are used, 76 annotation types, 302 annotations, 308 declarations, 130 interface declarations, 278 annotations, 308 declarations, 132 defaults for annotation type elements, 297 to context, 150 anonymous class declarations, 485 class instance creation expressions, 477, 477 class modifiers, 191 definite assignment and anonymous classes, 627 enum constants, 268 form of a binary, 377 initialization of fields in interfaces, 285 inner classes and enclosing instances, 197 to context, 151 where types are used, 76, 77 anonymous constructors, 485 choosing the constructor and its arguments, 484 default constructor, 265 form of a binary, 381 argument lists are evaluated left-to-right, 470 array access, 332 array access expressions, 491 array access, 332 assignment operators, 582 compound assignment operators, 589 simple assignment operator =,

34 to context, 151 unary numeric promotion, 125 array creation, 332 array creation and access expressions, 487 method reference expressions, 529 array creation expressions, 487 array creation, 332 array initializers, 335 objects, 53 to context, 151 unary numeric promotion, 125 where types are used, 76, 78 array initializers, 335 array creation, 332 definite assignment and array initializers, 626 normal and abrupt completion of evaluation, 464 objects, 53 run-time evaluation of array creation expressions, 488 array members, 336 declarations, 130, 130 happens-before order, 644 qualified expression names, 159 array store exception, 333 array variables, 332 assignment contexts, 109 expressions and run-time checks, 463, 464 normal and abrupt completion of evaluation, 465 variables, 80 array types, 330 annotation type elements, 294 enhanced for statement, 430 raw types, 66 reference types and values, 52 reifiable types, 65 where types are used, 77 array variables, 330 enhanced for statement, 431 formal parameters, 228 lambda parameters, 598 arrays, 329 array creation expressions, 487 kinds of variables, 83 when reference types are the same, 57 assert statement, 416 assert statements, 620 detailed initialization procedure, 365 when initialization occurs, 361 assert statements, 620 assignment contexts, 107 array initializers, 335 array store exception, 333 array variables, 332 class instance creation expressions, 478 execution of try-catch, 444 expressions and run-time checks, 463, 463 kinds of types and values, 42 lambda expressions, 595 method invocation expressions, 500 method reference expressions, 531 normal annotations, 310 reference conditional expressions, 580 return statement, 436 run-time evaluation of method references, 540 simple assignment operator =, 582, 583 switch statement, 420 throw statement, 437, 438 type of an expression, 461 variables, 80 assignment expressions,