Re: default constructor
memory for the new object is created with each instance field
initialized to the default for its type.
who make this?
I've seen in Object.java but I haven't found the Object constructor,
why?Because Object also uses a default constructor. The default
for Object has a completely empty body, with no explicit or implicit
superclass constructor call.
and than how they are initializated to that default values?
Try this: constructing an object is a multi-stage process.
First the storage used by the object is allocated by the JVM. At this point
the values of all fields are set to 0, false, or null. (In theory the JVM
might be able to optimise away some or all of this zeroing -- but only if there
is no conceivable way that you'd ever be able to detect it without using a
Second, one of three things happen:
If the object is an Object (not a subclass) then nothing happens ;-)
If the constructor explicitly delegates to another constructor or
to a superclass constructor (this(param...) or super(param...)) then
that constructor is called. That may in turn explicitly delegate...
Otherwise, there is no explicit delegation, in which case the
superclass's no-args constructor is called.
Third, any initialisers for instance fields are executed, this includes
anonymous initialisers (I forget the correct formal term). I.e. any
field-initialisation code like:
int i = 66;
String s = System.getProperty("XYZ");
int x, y;
x = 22;
y = 1;
for (int n = 1; n <= x; n++)
y *= n;
is, as it were, "patched in" to the constructor.
Lastly, the body of the constructor is executed.
There are a couple of minor caveats to the above: (1) if the object is an
instance of an inner class, then the (hidden and synthetic) field which points
to its "outer" is initialise /before/ the superclass constructor is called in
step 2. If the code delegates explicitly to another constructor, then the
values of the parameters will have to be computed before the call; for that
reason there are severe limits on what kind of code may be invoked at that
point -- basically you can only call code which does not refer to the object