Initialization and class loading

class
loading

In

many more traditional languages, programs are loaded all at once as part of the

startup process. This is followed by initialization, and then the program

begins. The process of initialization in these languages must be carefully

controlled so that the order of initialization of

s

doesn’t cause trouble. C++, for example, has problems if one

expects another

to

be valid before the second one has been initialized.

Java

doesn’t have this problem because it takes a different approach to

loading. Because everything in Java is an object, many activities become

easier, and this is one of them. As you will learn in the next chapter, the

code for each object exists in a separate file. That file isn’t loaded

until the code is needed. In general, you can say that until an object of that

class is constructed, the class code doesn’t get loaded. Since there can

be some subtleties with

methods, you can also say, “Class code is loaded at the point of first

use.”

The

point of first use is also where the

initialization takes place. All the

objects and the

code block will be initialized in textual

Initialization
with inheritance

It’s

helpful to look at the whole

//: Beetle.java
// The full process of initialization.
 
class Insect {
  int i = 9;
  int j;
  Insect() {
    prt("i = " + i + ", j = " + j);
    j = 39;
  }
  static int x1 =
    prt("static Insect.x1 initialized");
  static int prt(String s) {
    System.out.println(s);
    return 47;
  }
}
 
public class Beetle extends Insect {
  int k = prt("Beetle.k initialized");
  Beetle() {
    prt("k = " + k);
    prt("j = " + j);
  }
  static int x2 =
    prt("static Beetle.x2 initialized");
  static int prt(String s) {
    System.out.println(s);
    return 63;
  }
  public static void main(String[] args) {
    prt("Beetle constructor");
    Beetle b = new Beetle();
  }
} ///:~ 

The

output for this program is:

static Insect.x initialized
static Beetle.x initialized
Beetle constructor
i = 9, j = 0
Beetle.k initialized
k = 63
j = 39

The

first thing that happens when you run Java on

is that the loader goes out and finds that

If

the base class has a base class, that second base class would then be loaded,

and so on. Next, the

At

this point, the necessary classes have all been loaded so the object can be

created. First, all the primitives in this object are set to their default

values and the object handles are set to

.

Then

the base-class constructor will be called. In this case the call is automatic,

but you can also specify the constructor call (as the first operation in the

constructor) using

.

The base class construction goes through the same process in the same order as

the derived-class constructor. After the base-class constructor completes, the

instance variables are initialized in textual order. Finally, the rest of the

body of the constructor is executed.

|

|