Contents | Prev | Next | Index Java Language Specification
Third Edition


A

abrupt completion
See completion, abrupt
abstract modifier
See also declarations; modifiers
classes
anonymous are never, 335
binary compatibility considerations, 257
declaration of, 135
definition and characteristics, 135
direct superinterface relationship to, 142
methods
binary compatibility considerations, 268
classes, 170
declaration examples, 167, 205
interfaces, 205
overloading, 207, 208
overriding, 207
semicolon as body of, 176
and super method invocation, 355
access
See also scope
accessibility
determining, 105
term definition, 104
array, 211
expression evaluation order, 365
constructor, binary compatibility considerations, 261
of fields, expression evaluation, 341
inheritance of class members, example
default, 149
private, 151
protected, 150
public, 150
interface member names, 202
access (continued)
method, binary compatibility considerations, 267
non-public class instances, through public superclasses and superinterfaces, 151
overridden methods, using super keyword, 178
qualified
See also field access expressions; method invocation expressions
term definition, 104
access control
See also security
classes, example, 107
constructors
default, example, 108
private, example, 111
protected, example, 110
public, example, 109
fields
default, example, 108
private, example, 111
protected, example, 110
public, example, 109
methods
default, example, 108
private, example, 111
protected, example, 110
public, example, 109
package names, limited significance of, 120
protected, details of, 105
and qualified names, 104
term definition, 104
accessible
default for top-level types, 129
package, term definition, 105
accessible (continued)
single-type import must name a type that is, 126
type or package may not be named by type-import-on-demand if not, 127
types, members and constructors, term definition, 104
actions
See also methods
main memory subsystem
lock, 431
read, 431
unlock, 431
write, 431
prescient store, with threads, 438
thread
assign, 431
load, 431
lock, 431
store, 431
unlock, 431
use, 431
threads, constraints on relationships among, 433
algebraic identities
See also expressions; mathematical functions
limits on use of, 325
alphabet
See also syntax
components
See characters
data types
See primitive types
term definition, 9
ambiguity
See also names, ambiguous; scope
avoiding, in fields with multiple inheritance, 166
avoiding, in types with multiple inheritance, 188, 208
anonymous class, 135
See also inner class
and checked exceptions in initializers, 221
definite assignment before, 426
determining immediately enclosing instance when instantiating, 332
example(s), 161, 194
anonymous class (continued)
exceptions in instance initializer, 189
in an explicit constructor invocation, 194
interaction with shadowing of parameter names, 168
in an interface variable initializer, 204
protected accessibility of superclass constructor, 106
supertypes classified as type names, 95
term definition, 330
argument
See also parameters
lists, evaluation order, 326
values, method invocation conversion context, 71
arithmetic
See also floating point; integers; numbers; operators; primitive types
integer division, ArithmeticException, 321
operators, numeric promotion, specification, 77
arrays
See also classes; data structures
(chapter), 209
access, 211
expression evaluation order, 364
assignment, expression evaluation order, 394
character, distinguished from strings, 215
Class
objects, 215
obtaining, example, 53
Cloneable interface implemented by, 214
components
See also variables
assignment, run-time testing, 216, 320, 395, 400
default values, 51
initialization, 213
as a kind of variable, 48
type declaration, 213
creation, 42, 211
expression evaluation, 338
order, 338
out-of-memory detection, example, 340
example, 210
arrays (continued)
exceptions, ArrayStoreException, 217
indexing of, 211
initialization, 211, 212
members, 92, 213
names, fully qualified, 111
Object as superclass of, 215
origin, 211
variables
declaration, 210
initialization, 210
ASCII characters
See also characters; Unicode character set
Unicode character set relationship to, 14
assignment
See also fields; initialization
array, expression evaluation order, 394, 399
assignable to, term definition, 66
compatible, term definition, 66
compound
evaluation order, 323
operators, evaluation, 398
conversion context, specification, 56, 66
definite, (chapter), 407
expressions
boolean, definite assignment, 412
definite assignment, 412
as statements, 287
operation, to change value of primitive value, 33
simple operators, evaluation, 393
B

backslash (\)
escape sequence, 28
Unicode escape use, 15
backspace
escape sequence, 29
base
See also numbers
permitted in integer literals, 21
Beta, 3, 7
biblical quotations
I Corinthians 14:40, 322
John 3:30, 369
Matthew 6:29, 209
bibliographic references
Dynamic Class Loading in the Java Virtual Machine, 232
Polling Efficiently on Stock Hardware, 224
Release-to-Release Binary Compatibility in SOM, 251
binary
compatibility
See also code generation; compile-time errors; exceptions
(chapter), 251
changes that do not break, 252
compatible with, term definition, 256
contrasted with source compatibility, 257
file format, required properties, 253
name
See name, binary
numeric promotion, specification, 79
representation, verification of classesand interfaces, 232
blank final
field
class variable must be assigned by static initializer, 156
definite [un]assignment of, 418
definite assignment of, 407
instance variable must be assigned by every constructor, 156
notation for definite assignment, 412
restrictions in an inner class, 141
variable
definite unassignment of, 407
notation for definite unassignment, 412
blocks
See also control flow; statements
(chapter), 275
definite assignment, 418
enclosing, 141
in scope of exception handler parameters, 86, 306
in scope of local class, 86, 278
blocks (continued)
in scope of local variable, 85, 280
specification and execution of, 277
Bobrow, Daniel G., 6
body
See also declarations
class
declarations in, 147
term definition, 147
constructor, 192
binary compatibility considerations, 270
interface, declarations, 202
method, 176
binary compatibility considerations, 270
boolean
See also numbers
literals, term definition and specification, 25
operators, 40
types and values, term definition and specification, 40
bootstrap loader
See class loaders, bootstrap
brackets ([])
array type declaration, 41, 209, 280
break statement
See also control flow
definite assignment, 423
as reason for abrupt completion, 276
specification, 297
Burke, Edmund, 275
Burroughs, Edgar Rice, 301
Burton, Robert, xxiii
but not phrase
grammar notation use, 12
byte type
See also integral types; numbers; primitive types
value range, 33
C

C, 1, 2, 7
C++, 1, 2, 6
Caesar, Julius, 374
caller
of a statement, term definition, 222
carriage return (CR)
escape sequence, 29
handling in a
character literal, 26
string literal, 27
as a line terminator, not input character, 16
casting
See also conversion
boolean, 41
conversion context, 56
specification, 72
floating-point types, 38
integral types, 34
reference types, 73
run-time testing, 320
to void, not permitted, 287
catch clause, 303
See also control flow; try statement
exception handling role of, 219
exception idiom defined with, 226
scope of parameters, 86, 306
Cervantes, Migel de, 72
characters
See also numbers; primitive types; strings
array of, distinguished from strings, 215
char type, 31
See also integral types; numbers; primitive types
value range, 33
line terminators, 27
literals
escape sequences for, 28
term definition and specification, 26
Unicode character set
composite, contrasted with the Unicode decomposed characters, 20
handling in package names, 122
lexical grammar use as terminal symbols, 9
relationship to ASCII, 14
Chase, Lincoln, 118
checking
See also exceptions, checked; throw
for exception handlers, at compile-time, 221
Christie, Agatha, 276, 288, 347
circular declaration
of a class
compile-time error caused by, 144
circular declaration (continued)
of a class (continued)
example involving a local class, 278
link-time error caused by, 144
of an interface, compile-time error caused by, 201
of types, in different compilation units, legality of, 123
class literal, 95
class or interface name in a, 82
is a primary expression, 327
term definition, 328
class loaders
bootstrap, 248
and class unloading, 248
class(es)
See also fields; inheritance; interfaces; methods; packages; subclasses; superclasses; superinterfaces
(chapter), 135
abstract, 137
as array component types, 210
binary compatibility considerations, 257
overriding abstract methods in, 170
uses, 139
accessibility, 105
anonymous
See anonymous class
binary compatibility considerations, 257
binary representation
binary file format requirements, 256
verification of, 230
body
declarations, binary compatibility considerations, 259
term definition and declarations in, 147
.class suffix, as name for compiled files, 122
Class objects, associated with arrays, 215
constructors, binary compatibility considerations, 267
declarations, 136
specifying direct superclasses in, 142
specifying direct superinterfaces in, 144
term definition, 136
as declared entity, 81
exceptions
ClassCastException, 75
class(es) (continued)
exceptions (continued)
Error, 221, 226
Exception, 226
RuntimeException, 222, 226
Throwable, 219, 221, 226
final
binary compatibility considerations, 258
declaration of, 139
finalization of, 258
FP-strict, 319
inaccessible, accessing members of, 151 example, 151
initialization, 236
detailed procedure, 239
example, 231
instances
See instance(s)
instantiation, preventing, 190
linking
initialization, 227, 230, 239
preparation, 227, 234, 239
process description, 234
resolution, 230
at virtual machine startup, 230
loading, 232
errors
ClassCircularityError, 233
ClassFormatError, 233
NoClassDefFoundError, 233
process description, 233
at virtual machine startup, 230
local
See local class
member
See member class
members, 90
declarations, 147
binary compatibility considerations, 259
methods
class, 171
interface, 205
non-static, 172
static, 171
named, 135
and checked exceptions in initializers, 221
class(es) (continued)
names, fully qualified, 111
naming conventions, 114
nested
See nested classes
non-public, in example of qualified names and access control, 107
preparation, 234
at virtual machine startup, 230
preventing instantiation of, 139
public
access control in, 105
binary compatibility considerations, 258
in example of qualified names and access control, 107
references to, binary file format requirements, 253
resolution
exceptions
IllegalAccessError, 235
IncompatibleClassChangeError, 235
InstantiationError, 235
NoSuchFieldError, 236
NoSuchMethodError, 236
process description, 235
at virtual machine startup, 230
scope of, 85, 125
in scope of an imported type, 85, 125
static initializers, 189
binary compatibility considerations, 271
that depend on themselves
See circular declaration, of a class
that directly depend on a reference type
See circular declaration, of a class
top-level
See top-level class
type declarations, as members of packages, 129
unloading of, 248
variables
default values, 51
specification, 48, 155
verification, at virtual machine startup, 230
classification
reclassification of contextually ambiguous names, 96
classification (continued)
syntactic, of a name according to context, 94
code generation
See also binary, compatibility; compile-time errors; exceptions; optimization
asynchronous exceptions, implications for, 224
initialization, implications for, 241
symbolic reference resolution, implications of, 235
comments
term definition and specification, 18
Common Lisp, 6
compatibility
See binary, compatibility
compilation
See also compile-time errors; exceptions; virtual machine
CompilationUnit goal symbol, syntactic grammar use, 10
conditional
binary compatibility considerations, 265
if statement reachability handling to support, 314
exception handlers checked for during, 221
unit
components, package declarations, 124
and default accessibility of top-level types, 129
implicitly starts with import java.lang.*, 128
importing types into, 125
and meaning of a simple type name, 99
and name of top-level type, 129
overview, 119
and package membership, 89, 119
and package observability, 125
and scope of an import declaration, 85, 125
term definition and characteristics, 123
compile-time constant
See constants
compile-time errors
See binary, compatibility; errors; exceptions
completion, 276
See also control flow, exceptions
abrupt
break statement, 297
continue statement, 299
disallowed for static initializers, 189
during expression evaluation, 320
for statement, 295
labeled statements, 286
reasons for, 276, 321
return statement, 301
synchronized statement, 304
throw statement, 302
try statement, 305
try-catch statement, 307
try-catch-finally statement, 308
normal
during expression evaluation, 320
during statement execution, 276
required for instance initializers, 189
required for static initializers, 189
component(s)
See also arrays, components
type, arrays, 210
conflicts
name
See also hiding; obscuring; scope; shadowing
avoiding through use of syntactic context, 94
Conner, Michael, 251
constants
See also fields; class; final; fields, interface; literals
are always FP-strict, 319
characteristics and binary compatibility considerations, 264
compile-time narrowing of
by assignment conversion, implications, 66
not permitted by method invocation conversion, 71
expressions, 405
field, term specification, 264
may be declared in inner class, 140
named
See fields; class; final
constructors
See also class(es); execution; initialization; interfaces; methods
access, 105
binary compatibility considerations, 261
control
default, example, 108
private, example, 111
protected, example, 110
public, example, 109
hidden fields, this keyword use for, 283
accessibility, 105
allow field access through super, 344
anonymous
term definition, 335
anonymous class
cannot have explicitly declared, 335
has anonymous constructor, 335
are not members, 148
body, 192
binary compatibility considerations, 270
as components of a class body, 147
declarations, 190
binary compatibility considerations, 267
default, 195
definite assignment and unassignment within, 427
definite assignment of variables before, 418
deleting, binary compatibility considerations, 267
determining arguments to, 334
each must declare exceptions from instance initializers, 188
explicit invocation statements, 193
explicit invocations, 105
FP-strict, 319
invocation, during instance creation, 242
modifiers, 191
must assign all blank final instance variables, 156
must assign blank final fields, 156
names of, 83, 190
as non-members of a class, 90
overloading, 195
binary compatibility considerations, 270
parameters, 191
See also arguments
constructors (continued)
parameters (continued)
assignment during instance creation, 242
binary compatibility considerations, 267
definite [un]assignment of, 425
must not be assigned if final, 168
shadowing, 86, 168
specification, 51, 191
private, preventing instantiation with, 139, 197
protected, accessibility of, 105, 106
signature, 191
binary file format requirements, 255
throws clause, binary compatibility considerations, 270
and unreachable statements, 310
when reachable, 311
context(s)
See also inheritance; scope
conversion, 56
assignment, specification, 66
casting, specification, 72
method invocation, specification, 71
reclassification of contextually ambiguous names, 96
role in determining the meaning of a name, 81, 93
static
See static context
syntactic classification of a name according to, 94
context-free grammars
See grammars, context-free
continue statement
See also control flow
definite assignment, 423
as reason for abrupt completion, 276
specification, 299
contract
See also binary, compatibility
term definition, 256
control flow
See also completion; definite assignment; exceptions; expressions; statements; statements, unreachable; threads
boolean expressions use for, 40
control flow (continued)
break statement, specification, 297
continue statement, specification, 299
deadlock avoidance, multiple lock use for, 305
do statement, specification, 293
for statement, specification, 295
if statement, dangling else handling, 284
if-then statement, specification, 288
if-then-else statement, specification, 288
local variable declaration and switch statement, 49
return statement, specification, 301
switch statement, specification, 288
synchronized statement, specification, 304
throw statement, specification, 302
try statement, specification, 305
try-catch statement, specification, 307
try-catch-finally statement, specification, 308
while statement, specification, 292
conventions
naming, 113
impact on obscuring of names, 89
conversion
See also casting; numbers; promotion
(chapter), 55
casting, 72
contexts
assignment, specification, 66
casting, specification, 72
method invocation, specification, 71
forbidden, specification, 64
identity
in assignment conversion context, 66
in casting conversion context, 72
in method invocation conversion context, 71
specification, 58
kinds of, 58
in method invocations, 71
narrowing
primitive
in assignment conversion context, 66
in casting conversion context, 72
conversion (continued)
narrowing (continued)
primitive (continued)
not allowed in method invocation conversion context, reasons for, 71
reference, in casting conversion context, 72
reference
narrowing, 63
widening, 62
string, 72
specification, 64
term definition, 55
value set
in assignment conversion, 66
in binary numeric promotion, 79
in casting conversion, 72
in method invocation conversion, 71
in overview, 56
term definition, 65
in unary numeric promotion, 78
widening
primitive
in assignment conversion context, 66
in binary numeric promotion context, 79
in casting conversion context, 72
in method invocation conversion context, 71
in unary numeric promotion context, 78
reference, 62
in assignment conversion context, 66
in casting conversion context, 72
in method invocation conversion context, 71
term specification, 62
creation
See also declaration; initialization
array, 42, 211
expression evaluation
example, 339
order, 338
out-of-memory detection, example, 340
instance, 42
expression evaluation order, 334
expressions as statements, 286
creation (continued)
instance (continued)
invocation of initializers for instance variables during, 244
method dispatching during, 244
specification and procedure, 241
object, 42
threads, 445
Creatore, Luigi, 30
D

Danforth, Scott, 251
dangling else
See also control flow
handling of, 284
data
See also constants; fields; variables
structures
See arrays; classes; interfaces; primitive types; vectors
types
See types
values
See values
database
storing packages in, 119
deadlock
avoidance, multiple lock use for, 305
decimal
See also numbers
base, permitted in integer literals, 21
numerals, specification, 21
declarations
See also body; execution; methods; parameters; statements
class
(chapter), 135
body, 147
member, 147
term definition and specification, 135
constructor, 190
field(s), 153
constants in interfaces, 203
examples of, 162
interface, examples, 204
declarations (continued)
identifiers in, kept separate from those in labeled statements, 84
import
example, 128
single-type, 126
term definition, 125
type-import-on-demand, 127
instance variable, 48
interface, 200
(chapter), 199
body, 202
members, 202
local variable, definite assignment, 419
method(s), 167
examples of, 180
interface, abstract, 205
modifiers
See
abstract modifier; final modifier; native modifier; private modifier; protected modifier; public modifier; static modifier; synchronized modifier; transient modifier; volatile modifier
overriding, example, 180
package, in compilation units, 123
scope of, 85
shadowed, term definition, 86
shadowing, 86
subclass, 142
superclass, 142
superinterface, 144, 201
term definition, 82
type
as members of packages, 129
need not appear before use of the type, 86
usage in, 46
variable
array, 210
local, 279
execution of, 283
declarator
in scope of local variable, 85, 86, 280, 296
definite assignment
See also exceptions; execution; scope
definite assignment (continued)
(chapter), 407
and anonymous classes, 426
of blank final class variables, 156
of instance variables, 156
and local classes, 418
of member types, 426
and parameters, 425
and qualified class instance creation, 417
requirement for locals and parameters before an inner class, 141
and static initializers, 426
of variables with respect to nested classes, 418
definite unassignment, 407
See also definite assignment
hypothetical analysis of, 412
and local classes, 418
and qualified class instance creation, 417
and static initializers, 426
DeMichiel, Linda G., 6
denormalized
IEEE 754 standard, support required for, 38
digits
Java, term definition, 19
directly depends
class, term definition, 144
division
See also arithmetic; numbers
integer divide by zero, indicated by ArithmeticException, 34, 375
do statement
See also control flow
definite assignment, 421
specification, 293
double quote
escape sequence, 29
in string literals, 27
double type
floating-point literal specification, 24
Duff's device, 289
Dylan, 6
E

Eco, Umberto, 118
Eisenhower, Dwight D., 388
element type
arrays, term definition, 210
Ellis, Margaret A., 6
Ellison, Shirley, 118
entity
declared, list of, 82
Epictetus, 203
errors
class variable initializers may not refer to instance variables, 159
Error class, unchecked exceptions as subclass of, 176
linking, 227, 234
resolution, 235
verification, 234
loading, 227, 233
reasons for, 220
semantic, exceptions as mechanism for signaling, 219
types, run-time, 320
unchecked, reasons for, 221
virtual machine, 227
escapes
sequences, for character and string literals, 28
Unicode, specification, 14
evaluation
See also execution; initialization; scope
evaluated, term definition, 317
expressions
additive operators, 377
additive operators for numeric types, 381
array access, 364
array assignment, 393
array creation, 338
assignment operators, 392
bitwise binary operators, 388
bitwise complement, 371
boolean equality operators, 388
boolean logical operators, 389
cast, 372
compound assignment operators, 398
conditional operator, 391
conditional-and operator, 390
conditional-or operators, 390
division, 374
evaluation (continued)
expressions (continued)
equality operators, 386
field access, 341
instance creation, 334
integer bitwise operators, 389
logical binary operators, 388
logical complement, 371
method invocation, 345
method invocation, order of, 356
multiplication, 373
multiplicative operators, 373
numeric comparison, 384
numeric equality operators, 387
parenthesized, 330
postfix, 368
pre-decrement, 369
pre-increment, 369
primary, 327
reference equality operators, 388
relational operators, 384
remainder, 376
shift operators, 383
simple assignment operator, 393
string concatenation, 378
superclass access, 344
type comparison, 385
unary minus, 370
unary operators, 368
unary plus, 370
literals, 328
order
arguments left-to-right, 326
binary operators, 322
compound assignment, 323
left-hand operand first, 322
left-to-right, 322
operands evaluated before operations, 324
parentheses and precedence respected, 325
result of, term definition, 317
events
See also methods
execution order of, constraints on relationships among, 433
evolution
See also binary, compatibility; reuse
evolution (continued)
of classes, binary compatibility considerations, 257
of interface, binary compatibility considerations, 271
of packages, binary compatibility considerations, 257
examples
access control, 106
fields, methods, and constructors
default, 108
private, 111
protected, 110
public, 109
arrays, 212
classes, public and non-public, 107
declarations
fields, 162
import, 128
methods, 180
default-access methods, constructors, and fields, 108
exceptions, 224
fields
interface, ambiguous inherited, 204
interface, multiply inherited, 205
multiply inherited, 165
re-inheritance of, 166
hiding, 181
vs. overriding, 182
of variables
class, 162
instance, 163
inheritance
accessing members of inaccessible classes, 152
class members, 149
default access, 149
public, protected, and private access, 150
multiple, with superinterfaces, 146
with default access, 149
with private access, 151
with protected access, 150
with public access, 150
methods
abstract declarations, 207
invocation of hidden class, 184
examples (continued)
methods (continued)
private, 111
protected, 110
public, 109
overloading, 181
overriding, 180
vs. hiding, 182
incorrect, 181
because of throws, 186
large example, 185
exceptions
See also binary, compatibility; compile-time errors; errors;
(chapter), 219
asynchronous, causes and handling of, 224
caller, determination of, 222
causes of, 220
checked
constructors, declaring with throws clause in method declarations, 175
defining new exception classes as, 226
Exception, 226
in an instance initializer, 188
methods, declaring with throws clause in method declarations, 175
in a static initializer, 189
UnsatisfiedLinkException, 236
classes
Error, 221
Exception, 226
RuntimeException, 222
unchecked exceptions found in, 176
Throwable, 219, 221
errors
AbstractMethodError, 268
ClassCircularityError, 144, 258
meaning, 233
ClassFormatError, meaning, 233
Error, 226
ExceptionInInitializerError, 241, 304
IllegalAccessError, 258, 272, 358
meaning, 235
IncompatibleClassChangeError, 264, 269, 272, 357
meaning, 235
InstantiationError, meaning, 235
exceptions (continued)
errors (continued)
LinkageError, 233, 234
loading and linkage, 227
NoClassDefFoundError, 240
meaning, 233
NoSuchFieldError, 264
meaning, 236
NoSuchMethodError, 267, 273, 357
meaning, 236
OutOfMemoryError, 176, 233, 241, 242, 321, 334, 338, 340, 360
UnsatisifedLinkError
meaning, 236
VerifyError, 269, 272
meaning, 234
VirtualMachineError, 227
example, 224
handlers
compile-time checking, 221
how established, 219
in try statements, 306
handling of, 222
asynchronous, 224
run-time testing, 320
hierarchy, 226
integer divide by zero, 34
NegativeArraySizeException, 321, 338
never thrown for
assignment conversions, 66
information loss due to narrowing primitive conversions, 61
information loss sue to widening primitive conversions, 59
widening reference conversions, 63
NullPointerException, 194
parameters
See also variables
declaration, 306
description, 49
initial value, 51
scope, 86, 306
precise, 223
RuntimeException, 395
synchronization integrated with mechanism for handling, 220
exceptions (continued)
thrown for, narrowing reference conversions, 63
uncaughtException method, when invoked, 220
unchecked, 226
unchecked runtime
ArithmeticException, 324, 376
ArrayIndexOutOfBoundsException, 394, 399
ArrayStoreException, 217, 320, 395, 398
ClassCastException, 320, 372, 395
casting conversion requirements that can result in, 75
IndexOutOfBoundsException, 212, 321, 364
NullPointerException, 213, 222, 321, 358, 361, 364, 366, 394, 399
RuntimeException, 226, 395
execution
See also declarations; evaluation; initialization; linking; loading
(chapter), 229
order, thread rules, 433
of statements for their effect, 275
exit
virtual machine, criteria for, 249
exponent
See value set
expressions
See also fields; methods; statements
(chapter), 317
abrupt completion of, as reason forabrupt statement completion, 277
additive operators
evaluation, 377
for numeric types, evaluation, 381
array
access, evaluation, 364
assignment, evaluation, 394, 399
creation, evaluation of, 337
assignment
conversion, 66
definite assignment, 407, 412
operators, evaluation, 392
as statements, 287
expressions (continued)
bitwise
binary operators, evaluation, 388
complement, evaluation, 371
boolean
operators
!, definite assignment, 414
&&, definite assignment, 413
?, definite assignment, 414
||, definite assignment, 413
assignment, definite assignment, 415
constant, definite assignment, 412
equality, evaluation, 388
logical, evaluation, 389
cast, evaluation, 372
compound, assignment operators, evaluation, 398
conditional
and operator &&, evaluation, 390
operator ? :
definite assignment, 414
evaluation, 391
or operator ||, evaluation, 390
definite assignment and, 412
division, evaluation, 374
equality operators, evaluation, 386
field access, evaluation, 341
instance creation
evaluation of, 330
as statements, 286
integer bitwise operators, evaluation, 389
logical
comparison operators, evaluation, 388
complement !, evaluation, 371
method invocation
evaluation, 345
evaluation order, 356
as statements, 287
multiplication *, evaluation, 373
multiplicative operators *, \xda , %, evaluation, 373
names
context in which a name is classified as, 95
qualified, meaning of, 102
simple, meaning of, 101
numeric
comparison, evaluation, 384
expressions (continued)
numeric (continued)
equality operators, evaluation, 387
operators
++, definite assignment, 416
--, definite assignment, 416
precedence, evaluation, 325
parenthesized
evaluation of, 330
evaluation of, precedence effect of, 325
post-decrement --
evaluation of, 368
as statements, 287
postfix, evaluation, 367
post-increment ++
evaluation of, 367
as statements, 287
pre-decrement --
evaluation of, 369
as statements, 287
pre-increment ++
evaluation of, 369
as statements, 287
primary, evaluation of, 327
See also
arrays, access expressions;
arrays, creation;
expressions, parenthesized;
fields, access expressions;
instance, creation;
literals;
methods, invocations;
this keyword
reference equality operators ==, !=, evaluation, 388
relational operators <, >, <=, >=, evaluation, 384
remainder operator %, evaluation, 376
run-time checks of, 319
semantics and evaluation rules, (chapter), 317
shift operators <<, >>, >>>, evaluation, 383
simple assignment operator =, evaluation, 393
statements
definite assignment, 417
specification, 284
expressions (continued)
string concatenation +, evaluation, 378
superclass access, evaluation, 344
type
vs. class of object, 52
comparison instanceof, evaluation, 385
how determined, 52
usage in, 46
unary
minus -, evaluation, 370
operators, evaluation, 368
plus +, evaluation, 370
values, variable as, 318
extends clause
See also classes; implements; object-oriented concepts
in class declaration, specifying direct superclasses with, 142
in interface declaration, 201
F

Feeley, Mark, 224
fields
access control
default, example, 108
private, example, 111
protected, example, 110
public, example, 109
access expressions, evaluation, 341
of an array, 92, 214
of a class
binary compatibility considerations, 262
declarations, 153
examples of, 162
final, 156
binary compatibility considerations, 264
volatile declaration not permitted for, 158
multiply inherited, example of, 165
non-static
default values, 51
explicit constructors not permitted to use, 193
hiding example, 163
fields (continued)
of a class (continued)
non-static (continued)
initializers for, 159
initialization of, 158
invocation of initializers during instance creation, 242
specification, 48
re-inheritance of, example, 166
static
binary compatibility considerations, 266, 271
and final, binary compatibility considerations, 264
hiding of, example, 163
initialization of, 158, 189
initialization of, during the preparation phase of linking, 234
specification, 48
term definition and declaration, 155
transient, 156
binary compatibility considerations, 266
volatile, 156
declarations
binary compatibility considerations, 273
as declared entity, 81
hidden
accessing with
super keyword, 344, 345
this keyword, 283
of an interface
ambiguous inherited, example, 204
binary compatibility considerations, 273
declarations, 203
examples, 204
initialization, 204
during the preparation phase of linking, 234
multiply inherited example, 205
public by default, 203
names, naming conventions, 115
public, by default in interface declaration, 202
references to, binary file format requirements, 253
references, active use, 238
shadowing, 86
fifth dimension, 339
files
binary, format, 252
systems, storing packages in, 119
Finagle's Law, 219
final modifier
See also declarations; modifiers
anonymous class is always implicitly, 335
classes
binary compatibility considerations, 258
declaration of, 139
exception parameter, may not be assigned, 306
fields
binary compatibility considerations, 264
declaration and use, 156, 203
final by default in, interface declaration, 203
not allowed with volatile, 158
formal parameters, 168
methods
binary compatibility considerations, 268
declaration and use, 172
not permitted in interface method declarations, 206
reasons why constructors cannot be, 191
finalization
See also exceptions; linking
finalizable, as object attribute, 246
finalize method, as member of Object class, 45
finalized, as object attribute, 246
finalizer method calls, unordered nature of, 247
finalizer-reachable, as object attribute, 246
finally clause, exception handling use, 223
implementing, 246
of instances, 245
implementation procedures, 246
float type, 35
See also floating-point
floating-point
See also arithmetic; numbers; types
algebraic identities, limits on use of, 325
float type, floating-point literal specification, 24, 33
floating-point (continued)
literals
largest and smallest, 24
term definition and specification, 24
operations, 37
required behavior, 38
types and values, term definition and specification, 35
flow analysis
See also security
conservative, required for definite assignment of local variables, 407
Foote, Samuel, 305
for statement
definite assignment, 422
ForInit part
initialization by, 295
scope of local variable declared in, 86
header, local variable declaration in, 281
in scope of a local variable, 86, 296
specification, 295
form feed
escape sequence, 29
Forman, Ira, 251
forward reference
compile-time error in
initializers, 160
forward references
to types allowed before declaration, 86
FP-strict
actual arguments, 169
and addition, 382
and casts, 372
classes, 139
classes, interfaces, methods, constructors and initializers, 319
compile-time constant is always, 406
constructors, 191
and division, 375
expression
term definition, 318
interfaces, 200
methods, 173
overriding, 178
and multiplication, 374
and return statement, 302
value set conversion within, 65
Franklin, Benjamin, 229
Frost, Robert, 199, 310, 315, 445
G

Gabriel, Richard P., 6
Geisel, Theodore, 132
Gilbert, W. S., 197
goal symbols
CompilationUnit, 123
syntactic grammar use, 10
Input, lexical grammar use, 9
Goldberg, Adele, 6
goto statement
See labeled statements
gradual underflow
See also exceptions; floating-point; IEEE 754 standard; numbers
support required for, 38
grammars
See also languages; lexical; semantics
(chapter), 9
context-free, term definition, 9
difficulties with, as given in body of Java Language Specification, 449
if statement, dangling else handling, 284
lexical
(chapter), 13
term definition, 9
notation, 10
syntactic, term definition, 10
H

Hammerstein, Oscar, II, 133
Harbison, Samuel, 6
Harding, Warren G., 307
hexadecimal
See also numbers
base, permitted in integer literals, 21
numerals, specification, 22
hiding
See also scope
by class methods, 178
of field declarations, in superclasses and superinterfaces, 154
hiding (continued)
of fields, 136
bypassing using super, 345
term definition, 154
hidden class methods, invocation of, example, 184
of interface field declarations, in superinterfaces, 203
of interface fields, term definition, 203
of interface member type declarations, 208
of interface member types, term definition, 208
of interfaces, 199
of member types, term definition, 187
method
example, 181
impact on checked exceptions, 176
requirements, 178
of methods, 136
vs. overriding, example, 182
of types, by member types, 136
of variables
class, example of, 162
instance, example of, 163
hierarchy
exception, 226
Higginson, Thomas Wentworth, 203
Hoare, C. A. R., 1, 6
horizontal tab
escape sequence, 29
host
and creation, storage and observability of packages and compilation units, 120
may not restrict packagesin a database, 130
and observable compilation units, 123
optional restriction on packages in a file system, 129
hypothetical analysis
of definite unassignment, 412
I

identifiers
See also fields; names; scope; variables
identifiers (continued)
those that are not names, 83
in labeled statements, distinguished from those in declarations, 84
term definition and specification, 19
identity
conversion
in assignment conversion context, 66
in casting conversion context, 72
in method invocation conversion context, 71
specification, 58
IEEE 754 standard, 6
See also numbers
floating-point
conversion of numbers to, 24
types conformance to, 35
if statements
See also statements
dangling else, handling of, 285
definite assignment, 420
if-then statement, specification, 288
if-then-else statement, specification, 288
specification, 287
implement
See also classes; extends clause; interfaces
implements clause, 201
class declaration, specifying direct superinterfaces with, 144
term definition, 91, 145
import
See also packages; scope
automatic, 128
declarations
example, 128
single-type, 126
term definition, 125
type-import-on-demand, 127
imported types
as declared entity, 82
scope of, 85
as part of a compilation unit, 123
single-type
may not declare top-level type in same compilation unit, 130
and meaning of a simple type name, 99
import (continued)
single-type (continued)
scope, 85, 125
and shadowing, 87, 126
type-import-on-demand, 96
and meaning of a simple type name, 100
scope, 85, 125
and shadowing, 87, 127
indexing
of arrays, 211
inexact results
See also numbers
rounding behavior, 38
infinity
See also numbers
representation of, 25
signed, produced by floating-point overflow, 39
inheritance
See also object-oriented concepts; scope
in class
examples of, 149
of members, 148
of members, with public, protected, and private access, examples, 150
with default access, example, 149
of fields
in class declarations
multiply inherited from interfaces, example of, 165
reinheritance of, example of, 166
in interface declarations
ambiguous inherited, example, 204
multiply inherited, example, 205
of members, 90
of methods
in class declarations, 177
with the same signatures, 179
in interface declarations, 206
multiple
See also superinterfaces
example, 146
term definition, 90
initialization
See also control flow; linking
of arrays
in creation, to default value, 338, 48
initialization (continued)
of arrays (continued)
using array initializers, 212
of classes, 236
detailed procedure, 239
of classes and interfaces, when it occurs, 236
detailed procedure, 239
of fields
in classes, 159
in interfaces, 204
of for statement, 295
of interfaces, 236
detailed procedure, 239
for variables, array, 212
initializers
See also creation; execution
array
in array creation expression, 338
arrays, 211
executing, in Test class example initialization, 231
for fields
in class, 159
in interface, 204
instance
See instance initializer
FP-strict, 319
instance variable, 195
lacking in a blank final, 50
local variable
in scope of a local variable, 86, 296
static, 158, 189
binary compatibility considerations, 271
static
FP-strict, 319
variable
FP-strict, 319
in scope of local variable, 85, 280
for variables
class, 158
during class or interface initialization, 159
instance, 159
during instance creation, 242
inner class
See also nested class
anonymous class is always, 335
inner class (continued)
of another class, 140
direct, 140
every local class is an, 277
in a qualified class instance creation expression, 331
and qualified super method invocation, 355
qualified superclass constructor invocation of, 193
as superclass of an anonymous class, 334
term definition, 140
input
See also files
elements, term definition, 16
Input goal symbol, lexical grammar use, 9
tokens, 16
instance initializer, 135
allows field access through super, 344
anonymous class, 336
and checked exceptions, 221
as components of a class body, 147
containing a throw statement, 304
definite assignment of variables before, 418
execution during constructor invocation, 195
is not a member, 148
may not contain a return statement, 301
must be able to complete normally, 189
overview, 136
term definition, 188
and unreachable statements, 310
when reachable, 311
instance(s)
See also classes; interfaces; object-oriented concepts
creation, 42, 241
constructor
invocation by creation expressions, 190
parameter assignment during, 242
use in, 190
expression evaluation, 330
order, 334
expressions as statements, 287
invocation of initializers for instance variables during, 242
instance(s) (continued)
creation (continued)
method dispatching during, 244
enclosing
determining immediate, 332
with respect to superclass, 194
with respect to superclass of an anonymous class, 333
immediate as first argument to constructor, 334
immediately, 141
with respect to a class, 141
nth lexical used when evaluating method invocation, 356
nth lexically, 141
restrictions on references to, 194
finalization of, 245
implementation procedures, 246
initializer
See instance initializer
instanceof operator
testing expression types with, 320
testing expressions with, 320
instantiation
preventing, with private constructors, 139, 197
methods
See methods, non-static
variables
See fields, class, non-static
instanceof operator
testing expression types with, 320
instantiation
term definition, 330
integers
See also arithmetic; integral types; numbers
converting to boolean values, 41
literals
longest permitted, 23
term definition and specification, 21
operations, 33
integral types
See also arithmetic; numbers; types
byte type, 33
char type, 33
int type, 33
long type, 33
integral types (continued)
short type, 33
values and operations, 33
interfaces
See also class(es); fields; methods; packages; subclasses; superclasses; superinterfaces
(chapter), 199
abstract methods, 205
accessibility, 105
as array element types, 210
binary compatibility considerations, 271
binary representation
binary file format requirements, 252
verification, 234
body, declarations, 202
and checked exceptions in initializers, 221
Cloneable, implemented by arrays, 214
declarations, 200
as declared entity, 81
dependent on a reference type
term definition, 201
directly dependent on a reference type
term definition, 201
fields
declarations, 203
examples, 204
inheritance
ambiguous, 204
multiply, 205
initialization, 204
FP-strict, 319
initialization, 236
detailed procedure, 239
java.io.Serializable, implemented by arrays, 214
linking, process description, 233
loading, 232
process description, 233
members, 91
binary compatibility considerations, 272
declarations, 202
inheritance from superinterfaces, 91, 202
names, access to, 202
methods
declarations, 207
examples, 207
interfaces (continued)
methods (continued)
overloading, 207
example, 208
overriding, 206
example, 207
names
fully qualified, 111
naming conventions, 113
preparation of, 234
public
binary compatibility considerations, 272
declaration, 200
references to, binary file format requirements, 255
in scope of imported type, 85, 125
Serializable, implemented by arrays, 214
superinterfaces
binary compatibility considerations, 258
of a class, 144
declaration of, 144
that depend on themselves, 201
unloading of, 248
invocation
alternate constructor, 193
constructor
determining arguments to, 334
expression evaluation, 335
expression evaluation, order, 336
language constructs that result in, 190
of hidden class methods, example, 184
method
conversion, 71
expression evaluation, 345
order, 356
how chosen, 319
superclass constructor, 193
iteration
See also control structures
continue statement, specification, 299
do statement, specification, 293
for statement, specification, 295
while statement, specification, 292
J

Java
digits, term definition, 19
.java suffix, as name for source files, 122
java package is always in scope, 125
java.lang
example, 121
may be named in a type-import-on-demand, 127
public type names automatically imported from, 119, 123
java.lang package
public type names automatically imported from, 128
public types defined in, list of, 128
letters, term definition, 19
Java programming language
See also grammars; languages; lexical; semantics; syntax
Johnson, Samuel, 13
K

Keats, John, 217
Keene, Sonya E., 6
Kelvin, Lord (William Thompson), 317
Kernighan, Brian W., 7
keywords
list of, 20
as token, 10
Kiczales, Gregor, 6
L

label
shadowing, 87
labeled statements
identifiers in, kept separate from those in declarations, 84
specification, 286
language
See also grammars; lexical; semantics; syntax
Beta, 3, 7
C, 1, 2, 7
C++, 1, 2, 7
Common Lisp, 6
language (continued)
Dylan, 6
Mesa, 5, 7
Modula-3, 3, 6
Smalltalk-80, 6
Lao-Tsu, 81
left-hand side
term definition, 9
length
of array, 213
not part of type, 210
letters
See also Unicode character set
Java, term definition, 19
lexical
See also semantics; syntax
grammar, term definition, 9
structure (chapter), 13
translations, steps involved in, 14
Liang, Sheng, 233
life cycle
See also objects
of objects, 246
line terminators, term definition, 16
linefeed (LF)
escape sequence, 29
handling in a
character literal, 26
string literal, 27
as a line terminator, not input character, 27
linking, 233
See also exceptions; execution; initialization; loading; run-time
classes, process description, 233
errors, 227
interfaces, process description, 233
in Test class example, at virtual machine startup, 230
literals
See also constants; fields; variables
boolean, term definition and specification, 25
character
escape sequences for, 28
term definition and specification, 26
evaluation of, 328
floating-point
largest and smallest permitted, 24
literals (continued)
floating-point (continued)
term definition and specification, 24
integer
largest and smallest permitted, 23
term definition and specification, 21
null, term definition and specification, 29
string
escape sequences for, 28
term definition and specification, 27
term definition and specification, 21
as token, 10
loading
See also ClassLoader class; execution; linking
classes, 232
errors, 227
interfaces, 232
process, 233
in Test class example, at virtual machine startup, 230
local class, 115, 135
declaration is part of a block, 277
and definite [un]assignment, 418
determining immediately enclosing instance when instantiating, 332
example(s), 141, 278
interaction with shadowing of parameters, 168
and meaning of a simple type name, 99
requirements for normal completion, 311
scope, 86, 278
as superclass of anonymous class being instantiated, 333
term definition, 277
local variables
See also scope; variables
declarations
definite assignment, 419
statements, 279
declarators and types, 279
definite assignment, required for, 407
initial value, 51
naming conventions, 116
restrictions on use in an inner class, 141
scope, 85, 280
shadowing, 86
specification, 49
locks
See also monitors; synchronization; threads
(chapter), 429
acquisition and release
by synchronized networks, 174
by synchronized statement, 304
interaction with variables, rules about, 436
rules about, 436
synchronization and, 445
long type, 33
See also integral types; numbers
integer literal specification, 23
value range, 33
lvalue
See variables, value of expression
M

Madsen, Ole Lehrmann, 7
magnitude
loss of information about, possibility of in narrowing primitive conversion, 60
Marx, Chico, 415, 423
Marx, Groucho, 148, 227, 415, 416, 417
mathematical functions
See arithmetic; numbers
Matthew, St., 209
Maybury, William, 7
member, 187
member class, 82, 113, 135, 136
See also member type
can have same name as a method, 167
canonical name of, 113
determining immediately enclosing instance when instantiating, 332
example(s), 140, 142, 194, 196, 278
fully qualified name of, 112
and public modifier, 137
as superclass of anonymous class being instantiated, 333
term definition, 187
member interface, 82, 111, 113, 135, 136, 187
See also member type
can have same name as a method, 167
member interface (continued)
canonical name of, 113
example(s), 140
fully qualified name of, 112
implicitly static, 188
implicitly static, 140
inner class may not declare, 140
term definition, 187
member type, 97, 99, 187, 199
See also nested type
binary name of, 253
and definite assignment, 426
in interfaces, 208
inherited by interfaces, 201
and the meaning of a qualified type name, 100
and the meaning of a simple type name, 99
members
See also class(es); fields; interfaces; methods
accessibility, 105
arrays, 92, 213
classes, 90, 148
binary compatibility considerations, 259
declarations, 147
inaccessible, accessing, example, 151
inheritance, examples, 149
private, inheritance examples, 151
inheritance and, 90
interfaces, 91, 202
binary compatibility considerations, 272
declarations, 202
inheritance, 91, 202
names, access to, 202
Object class, 45
of a package, 89, 119
packages, 89, 119
protected accessibility of, 105
reference type, as declared entity, 81
static, restricted in inner classes, 140
of superclasses, accessing with super, 344
term definition, 89
memory
exceptions
OutOfMemoryError, 241, 242
main, term definition, 431
master, of variables, term definition, 431
memory (continued)
OutOfMemoryError, 176
working, term definition, 431
Mesa, 5, 7
method(s), 167
abstract
binary compatibility considerations, 268
in classes, 170
in interfaces
overloading, 207
access control
default, example, 108
private, example, 111
protected, example, 110
public, example, 109
access, binary compatibility considerations, 261
accessible, and method invocation, 347
of array, 92, 214
body, 176
binary compatibility considerations, 270
class
See methods, static
classes, 167
abstract, 170
binary compatibility considerations, 267
body
declarations, 176
with no executable code, 176
constructors compared with, 190
declarations, 167
examples of, 180
final, 172
hidden, invocation of, 184
hiding by, 178
modifiers, 169
native
declarations, 173
semicolon as body of, 177
private, as implicitly final, 172
signature, 169
strictfp, declaration, 173
synchronized, declaration, 174
void, expression return statement not permitted in, 177
with same signature, inheriting, 179
declarations, 167, 200
binary compatibility considerations, 267
method(s) (continued)
as declared entity, 81
definite [un]assignment of blank final fields before, 418
definite assignment of variables before, 418
descriptor, 347
dispatching during instance creation, 244
equals, as member of Object class, 45
final, 172
binary compatibility considerations, 268
finalize, as member of Object class, 45
FP-strict, 319
getClass, as member of Object class, 45
hashCode, as member of Object class, 45
hiding of, 178
inheritance
in arrays, 92, 214
in classes, 177
in interfaces, 91, 202
instance
See method(s), non-static
of interfaces
declarations, 205, 207
overloading, 207, 208
overriding, 206, 207
semicolon as body of, 176
invocation
See also access control
conversion, 71
expression evaluation, 345
order, 346
expressions as statements, 287
how chosen, 319
qualifying type of
See qualifying type, of a method invocation
as members of a class, 90
method table creation during preparation phase of linking, 230
names
context in which a name is classified as, 94
naming conventions, 115
qualified, meaning of, 104
simple, meaning of, 104
native, 173
binary compatibility considerations, 269
method(s) (continued)
non-static
instance method as name for, 172
overriding by, 177
notify, as member of Object class, 45
notifyAll, as member of Object class, 45
overloading, 180
binary compatibility considerations, 270
example, 181
overriding, 178
binary compatibility considerations, 271
examples, 180, 181, 182, 185, 207
parameters
See also arguments; variables
binary compatibility considerations, 267
definite [un]assignment of, 425
description, 48
initial value, 51
is assigned when final, 168
must not be assigned if final, 168
shadowing, 86, 168
specification of, 168
private, in example of qualified names and access control, 111
public, interfaces, declarations, 205
references to, binary file format requirements, 254
result type, binary compatibility considerations, 268
scope of formal parameters, 85, 168
shadowing, 87
signatures, 169
static, binary compatibility considerations, 269
stop, as asynchronous exception cause, 220
synchronized, 174
binary compatibility considerations, 270
throws clause, binary compatibility considerations, 270
toString, as member of Object class, 45
uncaughtException
exception handling use, 223
when invoked, 220
and unreachable statements, 310
wait, as member of Object class, 45
when reachable, 311
Mitchell, James G., 7
modifiers
See also declarations
class, 137
constructor, 191
declaration
See abstract modifier; final modifier; private modifier; protected modifier; public modifier; static modifier; strictfp modifier; synchronized modifier;transient modifier
field, 154
interface, 200
method, 169
Modula-3, 3, 6
Molière, 9
Møller-Pedersen, Birger, 7
monitors
See also locks; synchronization
term definition, 429
Montaigne, Michael de, 167
Moon, David A., 6
Morlay, Bernard de, 118
N

named class
exceptions in instance initializer, 188
named type, 200
names
See also identifiers; scope; Unicode character set
(chapter), 81
ambiguous
handling of, 93, 96
reclassification of, 96
binary
implementation keeps track of types using, 129
term definition, 253
canonical, 82
is binary name of top-level type, 253
and single-type imports, 126
term definition, 113
and type-import-on-demand, 127
class, naming conventions, 114
names (continued)
conflicts
See also hiding
avoiding
in fields with multiple inheritance, 165
through context use, 94
through naming conventions, 113
constants, naming conventions, 116
conventions, 113
impact on name obscuring, 89
expression
context in which a name is classified as, 97
qualified, meaning of, 102
simple, meaning of, 101
fields, naming conventions, 115
fully qualified, of a top-level type, 129
interface
member, access to, 202
naming conventions, 114
meaning of, determining, 93
method, 167
context in which a name is classified as, 96
naming conventions, 115
qualified, meaning of, 104
simple, meaning of, 104
package
in compilation units, 123
context in which a name is classified as, 97
limited significance for access control, 120
naming conventions, 113
qualified, meaning of, 98
scope, 125
simple, meaning of, 98
unique, 132
importance of, 132
parameters, naming conventions, 116
qualified
access control and, 104
fully, 111
term definition, 81
resolving references to, during resolution phase of linking, 230
restrictions, types and subpackages, 120
names (continued)
rules on being the same
class members, 90
fields, 90
interface fields, 92
simple, 253
class cannot have same as enclosing class, 137
interface cannot have same as enclosing class, 200
term definition, 83
as subset of identifiers, 83
syntactic
categories, 93
classification of according to context, 94
term definition, 83
type
context in which a name is classified as, 96
qualified, meaning of, 100
simple, meaning of, 99
variables, local, naming conventions, 116
NaN (Not-a-Number)
See also numbers
and addition, 381
comparison results, 39
and division, 375
and multiplication, 373
predefined constants representing, 25
preventing use of algebraic identities in expression evaluation, 325
term definition and specification, 35
narrowing
See also conversion; numbers
primitive conversions
in assignment conversion context, 66
in casting conversion context, 72
not allowed in method invocation conversion context, reasons for, 71
reference conversions, specification, 63
native modifier
See also declarations; modifiers
methods
binary compatibility considerations, 269
declaration, 173
semicolon as body of, 177
reasons why constructors cannot be, 191
nested class, 135, 136
nested class (continued)
See also nested type
and definite [un]assignment of variables, 418
inner class is a, 140
interaction with shadowing of parameters, 168
local class is a, 277
may declare static members if non-inner, 140
name hides same name in enclosing scopes, 148
term definition, 135
nested interface, 135, 136, 199
See also nested type, 135
term definition, 199
nested type
binary name of, 253
declaration
in scope of a class member, 85, 147
declarations
included in scope of interface members, 85, 202
in scope of an interface member, 85, 202
Newton, Sir Isaac, 1
non-public
classes, in example of qualified names and access control, 107
nonterminal symbols
See also grammars
definition of, notation for, 10
term definition, 9
notation
See also names, naming conventions
grammar, 10
notification
wait sets and, 446
null
literal, term definition and specification, 29
qualifying a superclass constructor invocation, 194
type
literal as source code representation of the value of, 20
term definition and specification, 32
numbers
See also arithmetic; precision; types
numbers (continued)
conversions of and to
See conversions
errors in handling
See exceptions
manipulating
See arithmetic operators
numeric promotion
binary, 79
specification, 77
term definition, 56
unary, 78
primitive types
See byte type; char type; double type; float type; floating-point; int type; integers; integral type; long type; short type
related types
See boolean; characters; strings
Nygaard, Kristen, 7
O

object-oriented concepts
See class(es); encapsulation; fields; inheritance; method(s); objects
objects
See also arrays; classes; instances; interfaces; types
Class, array, 215
fields that reference, final modifier effect on changes to, 50, 156
finalization attributes, 246
life cycle, 246
Object class, 44, 215
operations on references to, 43
reachable, finalization implication, 246
reference
See references
state
impact of changes, 43
transient fields not part of, 156
term definition and specification, 42
unreachable, finalization implications, 246
obscured
declaration, term definition, 89
label, 85
obscured (continued)
by labels, 286
of labels, 286
observable
all compilation units in javaand java.lang are, 123
compilation unit
determined by host, 120
term definition, 123
package
and meaning of qualified package name, 98
term definition, 125
Occam, William of, 373
octal
See also numbers
base, permitted in integer literals, 21
numerals, specification, 22
one of phrase
grammar notation use, 12
operators
See also constructors; expressions; initialization; methods; numbers
arithmetic, numeric promotion, specification, 77
assignment, as only way to change the value of a primitive variable, 33
binary, evaluation order, 322
boolean, 40
compound assignment, evaluation order, 323
floating-point, 37
signed infinity produced by overflow, 39
signed zero produced by underflow, 39
integer
divide, divide by zero exception thrown by, 34
overflow not indicated by, 34
underflow not indicated by, 34
integral, 33
list of, 30
operands evaluated before, 324
precedence, in expression evaluation, 325
on reference types, 43
remainder, divide by zero exception thrown by, 34
string concatenation
constructor invocation by, 190
operators (continued)
string concatenation (continued)
creating new instances with, 42
thread, term definition, 431
opt subscript
grammar notation use, 10
optimization
during
preparation phase of linking, 235
resolution phase of linking, 235
final method inlining, 172
finalization, 245
reachable objects reduction, 246
linking
initialization phase of, 240
resolution strategies, 234
optional symbol
term definition, 10
order
evaluation
argument lists left-to-right, 326
binary operators, 322
compound assignment, 323
left-hand operand first, 322
operands evaluated before operations, 324
of other expressions, 327
parentheses and precedence respected, 325
execution, thread rules, 433
field initialization, at run-time, 204
finalizer invocations, implications of no ordering imposition, 247
of floating-point values, 37
of occurrence, initialization of types, 236
thread interaction, consequences of, 430
origin
of arrays, 211
output
See files
overflow
See also arithmetic; exceptions; numbers
floating-point operators, signed infinity produced by, 39
not indicated by integer operators, 34
overloading
See also object-oriented concepts; inheritance; methods
overloading (continued)
of abstract interface methods
declarations, 207
example, 208
of constructors, 195
binary compatibility considerations, 270
of methods, 180
binary compatibility considerations, 270
example, 181
term definition, 91, 180
overriding
See also object-oriented concepts; scope
examples, 181, 182, 185, 207
incorrect, 181
incorrect because of throws, example, 186
large example, 185
methods
abstract
in abstract classes, 170
of non-abstract instance methods, 171
binary compatibility considerations, 271
in interfaces, 206
example, 207
instance, 177
requirements in, 178
term definition, 91
P

packages
(chapter), 119
binary compatibility considerations, 257
canonical name of, 113
declarations
in compilation units, 124
shadowing, 125
as declared entity, 81
host support for, 120
importing all public types from a, 127
members of, 89, 119
named, in compilation units, 124
names
context in which a name is classified as, 94
fully qualified, 111
packages (continued)
names (continued)
naming conventions, 113
qualified, meaning of, 98
simple, meaning of, 98
unique, importance of, 132
observable, 125
scope of, 85
shadowing, 87
storing in a
database, 122
file system, 121
term definition, 119
unnamed
compilation units belonging to, 123
in compilation units, uses and cautions, 124
and fully qualified name of top-level type, 129
Paine, Thomas, 305
parameters
See also modifiers; variable
constructor, 191
assignment during instance creation, 242
binary compatibility considerations, 267
description, 49
initial value, 51
as declared entity, 81
definite [un]assignment of, 425
exception
description, 49
initial value, 51
scope, 86, 306
method
binary compatibility considerations, 267
description, 48
initial value, 51
specification of, 168
must not be assigned if final, 168
names, naming conventions, 116
scope, 85, 168
shadowing, 86, 168
Partridge, Eric, 135
Peirce, Charles, 407
Peretti, Hugo E., 30
performance
See optimization
platform-dependent
native methods are, 173
pointers
See references
polling
for asynchronous exceptions, 224
precedence
See also expressions
of operators, in expression evaluation, 325
precise
term definition, 223
precision
See also numbers
possible loss of
in narrowing primitive conversions, 60
in widening primitive conversions, 58
preparation
of classes, 234
of interfaces, 234
in Test class example, at virtual machine startup, 230
prescient store
actions, with threads, 438
preventing
instantiation, 197
with private constructors, 139
primitive
See also numbers
conversion
narrowing
in assignment conversion context, 66
in casting conversion context, 72
not allowed in method invocation conversion context, reasons for, 71
widening
in assignment conversion context, 66
in binary numeric promotion context, 79
in casting conversion context, 72
in method invocation conversion context, 71
in unary numeric promotion context, 78
types
as array element types, 210
changing value of variables, 33
fully qualified name for, 111
primitive (continued)
types (continued)
literal as source code representation of the value of, 21
term definition and specification, 32
variables of, specification, 48
priority
thread, 445
private modifier
See also declarations; modifiers
access
determining, 105
inheritance of class members, example, 151
cannot be used for local classes, 278
class, pertains only to member, 137
constructors
access control, example, 111
preventing instantiation with, 139
fields, access control, example, 111
inheritance with, example, 151
and interfaces, 200
members not inherited, 148
methods
abstract not permitted with, 170
access control, example, 111
in example of qualified names and access control, 111
as implicitly final, 172
overriding and hiding not possible with, 179
preventing instantiation by declaring constructors as, 197
top-level type may not use, 131
productions
term definition, 9
promotion
See also numbers
(chapter), 55
numeric, 77
binary, 79
specification, 79
specification, 77
term definition, 56
unary, 78
specification, 78
protected modifier
See also declarations; modifiers
protected modifier (continued)
access, 105
cannot be use for local classes, 278
class, pertains only to member, 137
constructors, access control, example, 110
fields, access control, example, 110
inheritance with, example, 150
and interfaces, 200
methods, access control, example, 110
top-level type may not use, 131
public modifier
See also declarations; modifiers
access, 105
inheritance of class members, example, 150
cannot be used for local classes, 278
classes
access control in, 105
binary compatibility considerations, 258
in example of qualified names and access control, 107
pertains only to top-level and member, 137
constructors, access control, example, 109
fields
access control, example, 109
interface, implicit in declaration, 203
implicit for interface member types, 208
inheritance with, example, 150
interfaces
binary compatibility considerations, 272
declarations, 200
methods
access control, example, 109
in interfaces, implicit in declaration, 205
superclasses, accessing instances of non-public subclasses through, 151
superinterfaces, accessing instances of non-public subclasses through, 151
Q

qualified
See also access; scope
access, term definition, 104
class instance creation, 330
and definite [un]assignment, 417
qualified (continued)
class instance creation expression, 84
protected accessibility of constructor, 106
protected accessibility of superclass constructor, 106
names
access control and, 104
expression, meaning of, 102
fully, 111
method, meaning of, 104
not permitted with parameters, 168
package, meaning of, 98
term definition, 81
type, meaning of, 100
super, 193
superclass constructor invocation, 193
and protected accessibility, 106
qualifying type
of a constructor invocation
term definition, 255
of a field reference, term definition, 253
of a method invocation
as compile-time information stored for use at run-time, 355
term definition, 254
Quayle, J. Danforth, 220
R

Raper, Larry, 251
reachable
See also scope
objects
finalization implications, 246
term definition, 246
recursive
term definition, 10
references
See also expressions; types
conversions
narrowing, 63
widening, 62
in assignment conversion context, 66
in casting conversion context, 72
in method invocation conversion context, 71
references (continued)
to fields, active use, 238
forward
permitted in
class type usage, 131
interface type usage, 199
object, value of array variables as, 210
operations, 43
symbolic
binary file format requirements, 253
resolution, 235
term definition, 42
types
array, 210
class
See class
criteria for determining when two are the same, 45
interface
See interface
member name, scope of, 85
member, as declared entity, 81
specification, 41
in class declaration, 136
in interface declaration, 199
variables, specification, 48
release-to-release compatibility
See binary, compatibility
representation
binary, classes and interfaces, verification of, 234
resolution
late, in class and interface linking, 234
lazy, 231
name conflicts
avoiding with multiply inherited fields, 165
avoiding with multiply inherited types, 188, 208
context use in avoiding, 94
static, in class and interface linking, 234
symbolic references, 235
in Test class example, at virtual machine startup, 230
return statement
definite assignment, 423
instance initializer, 189
as reason for abrupt completion, 276
return statement (continued)
specification, 301
reuse, software
See binary, compatibility
right-hand side
term definition, 9
Ritchie, Dennis M., 7
Robson, David, 6
rounding
IEEE 754 standard default mode, support required for, 38
round to nearest, term definition, 38
round toward zero, term definition, 38
run-time
checks of expressions, 319
errors
See exceptions
RuntimeException class
unchecked exceptions found in, 176
state, linking binary objects into, 233
type, 52
validity checks, casting conversion requirements, 74
S

scope
See also declarations; inheritance; names; object-oriented concepts
of declarations, 85
formal parameter, 168
of formal parameters, 85, 168
of labels, 85, 286
of a local class, 86, 278
of local variable declared by for statement, 86, 295
member, 85, 147, 202
overview, 81
package, 125
parameters
formal, 168
shadowing rules, 86
of a top-level type, 85, 129
types declared by an import declaration, 85, 125
exception parameters, 306
in, term definition, 85
scope (continued)
initializer execution relative to issues of, 159, 160, 189
of a local class, 278
in method invocation expressions, 346
of names
of exception handler parameters, 86, 306
local variables, 49, 85, 280
parameters, formal, 85, 168
nested classes, variables and definite [un]assignment, 418
term definition, 85
type initialization order restrictions, 237
Sebastian, John, 288
security
See also access control; exceptions; types; virtual machine
internal symbolic reference table, role in maintaining, 232
type systems, verification importance to, 259
semantics
See also grammars; lexical; syntax
errors in, exceptions as mechanism for signaling at run-time, 219
expressions, (chapter), 317
names
context role, 94
determining, 93
expressions, 100
methods, 104
package, 98
types, 99
verifying during linking process, 234
semicolon (;)
as method body, 176
separators
list of, 29
as token, 10
sequences
escape, for character and string literals, 28
Seuss, Dr., 132
shadowing
absence of by statement labels, 286
of declarations, 86
by package declarations, 125
of exception parameters, 306
shadowing (continued)
of labels, 87, 286
of local classes, 278
by local variables, 283
of local variables, 280
and the meaning of a simple expression name, 101
and the meaning of a simple type name, 99
by member types, 187
of members by local variables, 282
of methods, 87
by a nested class, 148
package, 125
of packages, 87
parameters, 168
by single-type import, 87, 126
by type-import-on-demand, 87, 127
of types, 86
of variables, 86
Shakespeare, William, 30, 55, 118, 249, 436
Shelley, Percy Bysshe, 376
short type
See also integral types; numbers
value range, 33
side effects
See also expressions
from expression evaluation, reasons for, 317
signature
of constructors, 191
of methods, 169
methods with same, inheriting, 179
simple names
See also identifiers; names
expression, meaning of, 101
method, meaning of, 104
package, meaning of, 98
term definition, 83
type, meaning of, 99
single quote(')
escape sequence, 29
Smalltalk-80, 6
sorting
Unicode, reference for details on, 20
source code
compatibility, compared with binary compatibility, 257
source code (continued)
transformations that preserve binary compatibility, 253
Southey, Robert, 372
square brackets ([])
in array
type declaration, 210
variable declaration, 211
startup
virtual machine, 229
state
not shared by primitive values, 33
object
impact of changes, 43
transient fields not part of persistent, 156
statements
See also constructors; control flow; expressions; initializers; methods
(chapter), 275
break
definite assignment, 423
specification, 297
completion of
abrupt, reasons for, 276
normal, reasons for, 276
continue
definite assignment, 423
specification, 299
definite assignment, 417
do
definite assignment, 421
specification, 293
empty
definite assignment, 418
specification, 285
expression
definite assignment, 419
specification, 286
for
definite assignment, 422
specification, 295
general specification, 284
if
dangling else handling, 285
definite assignment, 420
if-then, specification, 288
if-then-else, specification, 288
statements (continued)
labeled
definite assignment, 419
scope of, 85, 286
specification, 286
local variable declarations
execution of, 283
specification, 279
return
definite assignment, 423
specification, 301
switch
definite assignment, 420
specification, 288
synchronized
definite assignment, 424
specification, 304
throw
definite assignment, 423
specification, 302
try
definite assignment, 424
try-catch, specification, 307
try-catch-finally, specification, 308
unreachable, conservative flow analysis detection of, 310
while
definite assignment, 421
specification, 292
static
restrictions in inner classes, 140
static context, 140
and method invocation, 355
and qualified superclass constructor invocation, 194
static initializer
definite [un]assignment within, 426
definite assignment of variables before, 418
inner class may not declare, 140
may not contain a return statement, 301
must assign all blank final class variables, 156
and unreachable statements, 310
when reachable, 311
static initializers
are not members, 148
and checked exceptions, 221
static initializers (continued)
overview, 136
static modifier
for fields
binary compatibility considerations, 266
creating during the preparation phase of linking, 234
default initialization of during the preparation phase of linking, 234
static modifier
for fields
initializers
as components of a class body, 147
for, 189
static modifier
See also declarations; modifiers
anonymous class is never, 335
cannot be used for local classes, 278
class, pertains only to member, 137
for fields, 155
declaring class variables using, 155
initialization of, 158
implicit in interface member declarations, 203
initialization of, 189
for methods
declaring class methods with, 171
hiding by, 178
not permitted in interface method declarations, 206
implicit for interface member types, 208
and interfaces, 200
reason why constructors do not use, 191
top-level type may not use, 131
Stein, Gertrude, 118, 370, 449
store
array, exception, 216
storing
packages
in a database, 122
in a file system, 121
strictfp modifier
constructors cannot be declared, 191
example(s), 325
for classes, 137
semantics, 139
and FP-strict expressions, 319
has no effect on method override, 178
strictfp modifier (continued)
interfaces, 200
methods may not be, 206
semantics, 200
methods, 169
semantics, 173
and widening conversion, 58
string(s)
See also characters; numbers; primitive types
character arrays are not the same as, 215
concatenation operator (+)
constructor invocation by, 190
creating new instances with, 42
conversion
context specification, 72
specification, 64
literals
escape sequences for, 28
interning of, 27
term definition and specification, 27
String class
creating instances, with string concatenation operator, 43
literal as source code representation of the value of, 21
specification, 45
string literal as reference to an instance of, 27
Stroustrup, Bjarne, 6
subclasses
See also class(es); interfaces; superclasses; superinterfaces
declaration, 143
direct, extending classes with, 142
relationship to direct subclass, 143
subpackage
as package member, 89, 119
and package observability, 125
super keyword
accessing
overridden methods with, 178
superclass members with, in expression evaluation, 344
binary compatibility considerations, 258
not permitted in
class variable initialization, 159
explicit constructor invocation, 192
super keyword (continued)
not permitted in (continued)
interface field declarations, 204
permitted
in instance initializers, 189
permitted in instance variable initialization, 160
superclass(es)
See also classes; fields; interfaces; methods; packages; subclasses; superinterfaces
accessing fields with super, expression evaluation, 344
of array is Object, 215
binary compatibility considerations, 258
direct
declaration, with extends clause, 142
term definition, 142
extending classes with, 142
public, accessing instances of non-public subclasses through, 151
superinterface(s)
See also classes; fields; interfaces; methods; packages; subclasses
binary compatibility considerations, 258, 272
direct
declaration, with implements clause, 144
term definition, 145
of interface, declaration, 201
public, accessing instances of non-public subclasses through, 151
term definition, 144
swapping
threads example, 439
Sweet, Richard, 7
switch
block, term definition, 289
switch statement
See also statements
definite assignment, 420
local variable declaration specification, impact on, 49
specification, 288
symbolic references
binary file format requirements, 253
resolution, 235
symbols
See also identifiers; name; variables
goal
CompilationUnit, 10
Input, 9
term definition, 9
nonterminal
notation for definition of, 10
term definition, 9
optional, term definition, 10
terminal, term definition, 9
synchronization
See also locks; threads
exception mechanism integration with, 220
initialization implications of, 239
locks, 445
use by synchronized methods, 174
use by synchronized statement, 304
synchronized modifier
See also modifiers
in method declarations, 174
methods, binary compatibility considerations, 270
reason why constructors do not use, 191
specification, 446
synchronized statement
definite assignment, 424
operations, 446
specification, 304
term definition, 429
volatile fields used for, with threads, 156
syntactic
See also lexical; semantics
classification, of a name according to context, 94
T

term definition
abrupt completion, 276, 322
access, 81
accessible, 104
control, 104
qualified, 104
action, 431
term definition (continued)
action (continued)
by main memory
lock, 431, 432
read, 431, 432
unlock, 431, 432
write, 431, 432
by thread
assign, 431, 432
load, 432
lock, 432
store, 431, 432
unlock, 431
use, 431
activation frame, 359
alphabet, 9
ambiguous member, 204
anonymous class, 330
applicable, 347
array, 209
components, 48, 209
element type, 209
type, 209
element, 209
empty, 209
initializer, 212
length of, 209
type, 209
assign, as thread action, 432
assignable to, 66
assignment, 66, 395
compatible with, 66
associated labels, 289
atomic, 431
binary
compatibility, 256
numeric promotion, 79
blank final, 50
block, 277
enclosing, 141
body
of class, 147
of constructor, 192
of interface, 202
of method, 176
break binary compatibility with, 256
break target, 298
caller, 222
term definition (continued)
can complete normally, 311
cast operator, 72, 368
catch clause, 219, 305
caught, 219, 302
checked exceptions, 221
class(es), 135, 136
abstract, 137
body, 147
declaration, 136
depends on a reference type, 144
direct inner, 140
directly depends on a reference type, 144
error, 221
exception, 222
final, 139
initialization, 236
inner, 140
inner of another class, 140
local, 277
modifiers, 137
of object, 52
runtime exception, 222
same, 46
strictfp, 139
unloading, 248
variables, 155
comments, 18
end-of-line, 18
traditional, 18
compatibility, binary, 256
compilation unit, 123
observable, 123
compile-time
declaration, 354
type, 47
compile-time type(s)
same, 45
complete
abruptly, 276, 321
normally, 276, 311, 321
component, 209
of array, 48, 209
type of array, 209
constant
expression
compile-time, 405
term definition (continued)
constructor(s), 190
anonymous, 335
default, 195
parameter, 49, 191
contain, 275
immediately, 275
context
static, 140
context of conversion, 56
continue target, 300
contract, 256
control
access, 104
conversion(s), 55
assignment, 66
casting, 72
contexts, 56
identity, 58
method invocation, 71
primitive
narrowing, 59
widening, 58
reference
narrowing, 63
widening, 62
string, 378
value set, 65
declaration(s), 82
array variable, 210
class, 135
variable, 48
compile-time, 354
constructor, 190
field, 153, 203
import, 125
instance variable, 48
interface, 202
local variable, 49
statement, 279
method, 167
package, 124
parameter
exception, 49
method, 48
shadowed, 86
single-type import, 126
top-level type, 128
term definition (continued)
declaration(s) (continued)
type-import-on-demand, 127
declarator, 279
default
constructor, 195
value, 51
definite assignment, 407
definitely assigned
after, 410
when false, 410
when true, 410
before, 410
definitely unassigned
after, 410
when false, 410
when true, 410
before, 410
direct
extension, 199
subclass, 142
superclass, 142
superinterface, 144, 201
directly implement, 199
dynamic method lookup, 358
dynamically enclosed, 222
element, 209
type, 209
empty
array, 209
statement, 285
enclosed, dynamically, 222
error classes, 221
escape
sequence, character and string, 28
Unicode, 14
evaluation
evaluated, 317
expression, result of, 317
order, 322
exception
caller of, 222
caught, 219
checked, 221
classes, 221
checked, 221
runtime, 222
unchecked, 221
term definition (continued)
exception (continued)
handler, 306
parameter, 49
polling for, 224
precise, 223
thrown, 219
unchecked, 221
executed, 317
exit of virtual machine, 249
expression, 317
constant, 405
statement, 287
extension, direct, 199
field, 153, 203
declaration, 153
final, 156, 203
non-static, 155
static, 155, 203
transient, 156
volatile, 156
finalizable, 246
finalization, object, 245
finalized, 246
finalizer, 245
finalize-reachable, 246
formal parameter, 168, 191
FP-strict expression, 318
frame activation, 359
goal symbol, 9
gradual underflow, 38
grammar
context-free, 9
lexical, 9
handler of exception, 306
handles, 223
hide, 178
a field, 154
an interface field, 203
an interface member type, 208
a member type, 187
identifier, 19
immediately contain, 275
implement, 91, 145, 177
directly, 199
implemented, 164
import
on demand, 127
term definition (continued)
import (continued)
single type, 126
in scope, 85
inexact, 38
infinities, 35
inherited, 90, 164
inherits, 177
initializer
array, 212
static, 189
variable, 158
input elements, 16
instance
of class, 42
immediately enclosing, 141
immediately enclosing with respect to a class, 141
initializer, 188
lexically enclosing, 141
method, 172
variables, 155
instantiation, 330
interface(s)
abstract, 200
body, 202
initialization, 236
same, 46
strictfp, 200
top-level, 199
invocation
alternate constructor, 193
superclass constructor, 193
iteration statements, 300
Java
digits, 19
letters, 19
keyword, 20
label, 286
associated, 289
language, 9
left of, to the, 17
left-hand side, 9
length of array, 209
line terminator, 16
linking, 233
literal, 21
boolean, 25
term definition (continued)
literal (continued)
character, 26
floating-point, 24
integer, 21
null, 29
string, 27
load action by thread, 432
loading, 232
local variable, 49
declaration statement, 279
locks, 431
lock action
by main memory subsystem, 432
by thread, 432
unlock action
by main memory subsystem, 432
by thread, 432
lookup
dynamic method, 358
loss of precision, 59
main memory, 431
master copy, 431
maximally specific, 350
member class, 187
member interface, 187
members, 89
ambiguous, 204
dynamic lookup, 358
memory
main, 431
working, 431
method(s), 167
abstract, 170, 205
applicable, 347
body, 176
class, 171
final, 172
hidden, 178
instance, 172
interface, 205
lookup, dynamic, 358
maximally specific, 350
more specific, 350
most specific, 347, 349, 350
native, 173
non-static, 172
overloaded, 180
term definition (continued)
method(s) (continued)
parameter, 48
signature, 169, 191
static, 171
synchronized, 174
modifiers
class, 137
constructor, 191
field, 155
interface, 200
method, 169
monitors, 429
more specific, 350
most specific, 349, 350
name(s), 83
ambiguous, 93
canonical, 113
contextually ambiguous, 96
expression, 96
method, 96
package, 96
qualified, 83
simple, 83
type, 96
unique package, 132
NaN (Not-a-Number), 35
narrowing
primitive conversion, 59
reference conversion, 63
nested class, 135
non-static
field, 155
method, 172
nonterminal, 9
normal completion, 276, 321, 322
notification, 446
numeric promotion, 77
object(s), 42
class of, 52
target, 358
obscured declaration, 89
observable
package, 125
operators, 30
additive, 377
assignment, 392
bitwise, 388
term definition (continued)
operators (continued)
cast, 372
equality, 386
logical, 388
multiplicative, 373
relational, 384
shift, 383
unary, 368
order of evaluation, 322
ordered, 37
overload, 180, 207
override, 206
package(s)
accessible, 105
unique names, 132
parameter, 168
constructor, 49, 191
exception handler, 49, 306
formal, 168, 191
method, 48, 168
pointer, 42
polling for exceptions, 224
precise exception, 223
precision, loss of, 59
preparation, 234
prescient store, 438
primitive conversion
narrowing, 59
widening, 58
priority, threads, 445
productions, 9
promotion
numeric, 77
binary, 79
unary, 78
qualified
access, 104
name, 83
qualifying type
of a field, 253
of a method invocation, 254
reachable, 246, 275, 311
read action
by main memory, 432
reason, 220, 276, 321
recursive, 10
reference, 42
term definition (continued)
reference (continued)
conversion
narrowing, 63
widening, 62
target, 356
types, 41
resolution, 235
late, 234
lazy, 234
result, 317
right of, to the, 17
right-hand side, 9
round
to nearest, 38
toward zero, 38
runtime exception classes, 222
run-time type(s)
same, 46
same
class, 45
compile-time type, 45
interface, 45
run-time class, 46
run-time interface, 46
run-time type, 46
scope, 85
separator, 29
signature, 169, 191
simple name, 83
specific
maximally, 350
more, 350
most, 349, 350
statements, 275
empty, 285
expression, 286
iteration, 300
labeled, 286
local variable declaration, 279
unreachable, 310
static
field, 155
initializers, 189
method, 171
resolution, 234
store
action by thread, 432
term definition (continued)
store (continued)
prescient, 438
strongly typed, 31
subclass, 143
direct, 142
subinterface, 202
superclass, 143
direct, 142
superinterfaces, 145, 201
direct, 144, 201
symbol
goal, 9
nonterminal, 9
optional, 10
terminal, 9
synchronizing, 429
target
break, 298
continue, 300
object, 358
reference, 356
terminal symbol, 9
thread, 429
thrown, 219, 220
throws clause, 175
token, 9, 16
top-level class, 135
type(s), 32, 52
boolean, 33
compile-time, 47
floating-point, 33, 35
import
on demand, 127
single, 125
integral, 33
null, 32
numeric, 33
primitive, 32
reference, 41
typed
strongly, 31
unary numeric promotion, 78
unchecked exception, 221
classes, 221
underflow
gradual, 38
unfinalized, 246
term definition (continued)
Unicode escapes, 14
unique package name, 132
unloading of classes, 248
unlock, 429
action
by main memory, 432
by thread, 432
unordered, 37
unreachable, 310
unreachable object, 246
use
action by thread, 432
value
default, 51
of expression, 318
value set
double, 35
double-extended-exponent, 35
float, 35
float-extended-exponent, 35
variable(s), 47, 431
class, 48, 155
final, 50
instance, 48, 155
local, 49
verification, 234
virtual machine exit, 249
visible, 87
wait set, 446
white space, 17
widening
primitive conversion, 58
reference conversions, 62
working
copy, 431
memory, 431
write action
by main memory, 432
terminal symbol
term definition, 9
terminators
line
carriage return and linefeed characters as, 27
term definition, 27
Test
program, how to run, 5
this keyword
accessing hidden fields with, 283
evaluation of, 328, 329
during instance creation, 242
not permitted
in class variable initialization, 159
in explicit constructor calls, 192
in interface field declarations, 204
permitted
in instance initializers, 189
in instance variable initialization, 160
qualified, 82
Thompson, William (Lord Kelvin), 317
threads
See also synchronization
(chapter), 429
constraints on relationships among actions of, 433
creation, 445
initialization implications of multiple, 239
interaction order, consequences of, 430
locks acquisition and release, by synchronized statement, 304
out-of-order writes example, 443
swapping example, 439
synchronized modifier, methods, declaration, 174
termination and virtual machine exit, 249
volatile fields use with, 156
throw
See also control flow; exceptions
throw statement
definite assignment, 423
as reason for abrupt completion, 276
specification, 302
throws clause, 189
of an anonymous constructor, 336
checked exception classes named in, 221
constructors, 192
binary compatibility considerations, 270
incorrect overriding because of, example, 186
methods, 175
binary compatibility considerations, 270
relation to instance initializers, 188
tokens
See also grammars
term definition, 9, 16
top-level class, 96, 111, 113
accessibility of, 105
and binary names, 253
canonical name of, 113
as package member, 89, 119
and private access, 105
and public modifier, 137
term definition, 135
top-level interface, 111
canonical name of, 113
as package member, 89, 119
term definition, 199
top-level type
binary name of, 253
fully qualified name of, 129
as part of a compilation unit, 123
scope, 85, 129
transient modifier
See also declarations; modifiers
fields, 156
binary compatibility considerations, 266
translations
lexical, steps involved in, 14
try statements
See also control flow; exceptions; statements
definite assignment, 424
exception handling role of, 222
scope of parameters to exception handlers, 86, 306
specification, 305
try-catch statement, specification, 307
try-catch-finally statement, specification, 308
types
See also arrays; classes; interfaces; primitive, types
(chapter), 31
argument values, method invocation conversion context, 71
array
canonical name of, 113
members of, 92
syntax and specification, 210
binary compatibility considerations, 256
boolean
Boolean literal specification, 25
term definition and specification, 40
types (continued)
char
character literal specification, 26
class
members of, 90
naming conventions, 114
compile-time, 52
data values relation to, 32
declaration of, as members of packages, 128
double, floating-point literal specification, 24
elements, of array, 209
errors, run-time testing, 320
expression
assignment conversion, 66
how determined, 52
of expressions, 318
float, floating-point literal specification, 24
floating-point, term definition and specification, 35
imported
as declared entity, 82
scope of, 85, 125
importing, compilation units, 123
int, integer literal specification, 21
integral, 33
interface
implications for variables and expressions, 52
members of, 91
naming conventions, 114
local variables, declaration of, 279
long, integer literal specification, 21
name(s)
context in which a name is classified as, 96
qualified, meaning of, 100
simple, meaning of, 99
named, 125
null, term definition and specification, 32
parameter, method invocation conversion context, 71
primitive
as array element types, 210
do not share state, 33
fully qualified name, 111
types (continued)
primitive (continued)
term definition and specification, 32
variables, specification, 48
qualifying
See qualifying type
reference
as array element types, 210
criteria for determining when two are the same, 45
member, as declared entity, 81
specifying with
class declaration, 135
interface declaration, 200
term definition and specification, 41
variables, specification, 48
run-time, 52
term definition, 52
term definition and specification, 32
usage, 46
in declarations and expressions, 47
of variable, how determined, 52
where used, 46
U

unary
numeric promotion, specification, 78
unassignment
definite
See definite unassignment, 407
unchecked
exceptions, 226
underflow
floating-point operators, signed zero produced by, 38
integer operators, not indicated by, 34
unfinalized
as object attribute, 246
term definition, 246
Unicode character set
See also characters
character sequences, represented by instances of class String, 45
composite characters, contrasted with the Unicode decomposed characters, 20
Unicode character set (continued)
escapes, 14
specification for handling, 14
term definition, 14
use when suitable font not available, 15
handling in package names, 122
lexical grammar use in terminal symbols, 9
sorting, reference for details on, 20
writing any character in, using ASCII characters in escapes, 15
unloading
See also linking; loading
of classes and interfaces, 248
of interfaces, 248
unqualified
class instance creation
and definite [un]assignment, 416
class instance creation expression, 95
unreachable
See also exceptions
objects
finalization implications, 246
term definition, 246
statements, conservative flow analysis detection of, 310
term definition, 246
V

value
return, specifying method with no, 167
value set
and contents of local variables, 280
conversion
See conversion, value set, 65
double, term definition, 35
double-extended-exponent, term definition, 35
float, term definition, 35
float-extended-exponent, term definition, 35
and FP-strict expressions, 318
and return statement, 302
values
See also assignment; initialization; primitive, types; variable
values (continued)
(chapter), 31
boolean, term definition and specification, 40
data, relation to types, 32
expressions, variables as, 318
floating-point, term definition and specification, 35
integral, term definition and specification, 33
primitive, term definition and specification, 32
reference
See references
relation to types, 32
variables, initial and default, 50
variables
See also data structures; fields; identifiers; scope
(chapter), 31
assignment conversion, 66
double, nonatomic treatment of memory operations on, 435
interaction with locks, rules about, 436
kinds of
array
See arrays, components
constructor parameters
See parameters, constructor
exception-handling parameters
See exceptions, parameters
instance
See fields, class, non-static
local
See variables, local
method parameters
See parameters, method
local, 279
declaration statements, 279
as declared entity, 81
definite assignment, declarations, 419
description, 49
naming conventions, 116
scope of, 86, 296
shadowing of names by, 283
long, nonatomic treatment of, memory operations on, 435
variables (continued)
primitive type
changing value of, 33
specification, 48
reference type, specification, 48
term definition and specification, 47
thread use constraints, 434
type of, how determined, 52
values
of expressions, 318
held by different types, summary of, 31
initial and default, 50
volatile, rules about, 437
verification
See also security
of binary representation, of classes and interfaces, 234
type safety dependence on existence and use of, 259
virtual machine
See also exceptions; optimization
class file format specified in, 252, 253
errors, 227
exception handling by, 219
exit, criteria for, 249
object life cycle in, 246
startup, 229
visible, 85
method, and meaning of method invocation, 346
term definition, 87
void keyword
See also methods
casting to, not permitted, 287
methods
expression return statement not permitted in, 177
no return value specified by, 167
volatile modifier
See also declarations; modifiers
fields, 156
used for synchronization by threads, 157
final declaration not permitted for, 158
variables, rules about, 437
W

wait
See also synchronization
wait sets, notification and, 446
Webb, Jim, 358
Weiss, George David, 30
while statement
See also control flow
definite assignment, 421
specification, 292
white space
term definition, 17
Whitman, Walt, 31, 80, 190, 273, 308
widening
See also conversions
primitive conversion
in assignment conversion context, 66
in binary numeric promotion context, 79
in casting conversion context, 72
in method invocation conversion context, 71
in unary numeric promotion context, 78
reference conversion, 62
in assignment conversion context, 66
in casting conversion context, 72
in method invocation conversion context, 71
Wordsworth, William, 54, 208, 320, 429
Z

zero
See also exceptions; numbers
divide by, exceptions thrown by integer divide and remainder operators, 34
Index

Contents | Prev | Next | Index Java Language Specification
Third Edition

Copyright © 1996-2005 Sun Microsystems, Inc. All rights reserved
Please send any comments or corrections via our feedback form



Spec-Zone.ru - all specs in one place



free hit counter