10.3

Array Creation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195

10.4

Array Access . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195

10.5

Arrays: A Simple Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196

10.6

Arrays Initializers  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196

10.7

Array Members . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197

10.8

Class

 Objects for Arrays  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199

10.9

An Array of Characters is Not a

String

. . . . . . . . . . . . . . . . . . . . . . . . . . 199

10.10 Array Store Exception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199

11

Exceptions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  201

11.1

The Causes of Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202

11.2

Compile Time Checking of Exceptions  . . . . . . . . . . . . . . . . . . . . . . . . . . 203

11.2.1

Why Errors are Not Checked  . . . . . . . . . . . . . . . . . . . . . . . . . . . 203

11.2.2

Why Runtime Exceptions are Not Checked . . . . . . . . . . . . . . . . 203

11.3

Handling of an Exception  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204

11.3.1

Exceptions are Precise. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205

11.3.2

Handling Asynchronous Exceptions . . . . . . . . . . . . . . . . . . . . . . 205

11.4

An Example of Exceptions  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206

11.5

The Exception Hierarchy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208

11.5.1

The Classes

Exception

 and

RuntimeException

 . . . . . . . . . . . 208

11.5.1.1

Standard Runtime Exceptions . . . . . . . . . . . . . . . . . . 208

11.5.1.2

Standard Checked Exceptions . . . . . . . . . . . . . . . . . . 210

11.5.2

The Class

Error

 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211

11.5.2.1

Loading and Linkage Errors  . . . . . . . . . . . . . . . . . . . 211

11.5.2.2

Virtual Machine Errors  . . . . . . . . . . . . . . . . . . . . . . . 212

12

Execution  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  215

12.1

Virtual Machine Start Up  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215

12.1.1

Load the Class

Test

 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216

12.1.2

Link

Test

: Verify, Prepare, (Optionally) Resolve  . . . . . . . . . . . 216

12.1.3

Initialize

Test

: Execute Initializers  . . . . . . . . . . . . . . . . . . . . . . 217

12.1.4

Invoke

Test.main

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218

12.2

Loading of Classes and Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218

12.2.1

The Loading Process . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219

12.2.2

Loading: Implications for Code Generation . . . . . . . . . . . . . . . . 219

12.3

Linking of Classes and Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220

12.3.1

Verification of the Binary Representation . . . . . . . . . . . . . . . . . . 220

12.3.2

Preparation of a Class or Interface Type . . . . . . . . . . . . . . . . . . . 221

12.3.3

Resolution of Symbolic References  . . . . . . . . . . . . . . . . . . . . . . 221

12.3.4

Linking: Implications for Code Generation  . . . . . . . . . . . . . . . . 222

12.4

Initialization of Classes and Interfaces  . . . . . . . . . . . . . . . . . . . . . . . . . . . 223

12.4.1

When Initialization Occurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223

12.4.2

Detailed Initialization Procedure. . . . . . . . . . . . . . . . . . . . . . . . . 225

12.4.3

Initialization: Implications for Code Generation  . . . . . . . . . . . . 227

12.5

Creation of New Class Instances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228

12.6

Finalization of Class Instances  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231

12.6.1

Implementing Finalization  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232

xii