Java SE 10 Language Specification

需积分: 1 14 浏览量更新于2024-07-18 收藏 3.18MB PDF 举报

"Java语言规范英文第十版，由James Gosling、Bill Joy、Guy Steele、Gilad Bracha和Alex Buckley等人编写，是Java SE 10版本的官方规范，发布于2018年3月。此规范在Oracle官网提供下载，详细阐述了Java编程语言的各个方面。" 《Java语言规范》第十版详细介绍了Java编程语言的标准，它是Java开发者的重要参考文档。本规范分为多个章节，涵盖了从语法到语义的各个方面，旨在确保Java程序的可移植性和一致性。 1. **介绍** (Introduction) - **组织结构** (Organization of the Specification): 规范的组织结构清晰，便于读者理解和查找信息。 - **示例程序** (Example Programs): 提供示例代码帮助解释语言特性。 - **表示法** (Notation): 描述了规范中使用的符号和表示方式。 - **与预定义类和接口的关系** (Relationship to Predefined Classes and Interfaces): 说明Java标准库中的核心类和接口与语言规范的联系。 - **反馈** (Feedback): 鼓励读者对规范提出意见和建议。 - **参考文献** (References): 列出相关的标准和技术文档。 2. **语法** (Grammars) - **上下文无关文法** (Context-Free Grammars): 描述了Java的词法和语法结构。 - **词法文法** (The Lexical Grammar): 定义了Java源代码的词汇元素。 - **句法文法** (The Syntactic Grammar): 描述了有效Java程序的结构。 - **语法表示法** (Grammar Notation): 介绍了用于表示文法的记号规则。 3. **词法结构** (Lexical Structure) - **Unicode** (Unicode): Java语言支持Unicode字符集。 - **词法转换** (Lexical Translations): 解释了如何将输入转换为源代码的逻辑表示。 - **Unicode转义** (Unicode Escapes): 详细描述了如何使用Unicode转义序列表示特殊字符。 - **行终止符** (Line Terminators): 规定了不同平台上的行结束标志。 - **输入元素和标记** (Input Elements and Tokens): 定义了源代码的基本构建块。 - **空白** (Whitespace): 解释了空白字符在源代码中的作用。 - **注释** (Comments): 描述了Java中的单行和多行注释规则。 - **标识符** (Identifiers): 规定了变量、类名和其他标识符的命名规则。 - **关键字** (Keywords): 列出了Java中的所有保留关键字。 - **字面量** (Literals): 包括整型、浮点型、字符型、字符串型以及布尔型字面量的详细说明。这部分仅涵盖了规范的前三章内容，实际规范中还包含了类型系统、表达式、声明、包、类和接口、异常处理、方法、循环、跳转语句、数组、初始化器、注解、模块系统等更多深入的Java语言特性。这些章节详细规定了Java语言的每一个方面，是理解、编写和调试Java代码不可或缺的参考资料。

1.1 Organization of the Specification 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

INTRODUCTION 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,

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

1.1 Organization of the Specification INTRODUCTION

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.

剩余771页未读，继续阅读

sohardto

粉丝: 0
资源: 1

Java SE 10 Language Specification

java 语言程序设计 第十版 复习题答案

java程序语言设计第十版复习题答案

Java语言规范十一版

java程序语言设计 梁勇 第十版

java语言程序设计原书第十版复习题课后题答案

Java语言编码规范.pdf

java语言程序设计原书第十版（基础+进阶）课后习题答案源代码

Java核心技术第十版源码

Java语言程序设计第10版（基础篇）课后题答案

java编程语言代码规范（中文）

最新资源

java 语言程序设计第十版复习题答案

java程序语言设计梁勇第十版