Sponsored Link •
This article describes the process of object initialization in Java programs. It discusses constructors, initializers, instance initialization (
<init>) methods, initialization and inheritance, object images on the heap, and the order in which an object's variables get initialized.
An object is a chunk of memory bundled with the code that manipulates memory. In the memory, the object maintains its state (the values of its instance variables), which can change and evolve throughout its lifetime. To get a newly-created object off to a good start, its newly-allocated memory must be initialized to a proper initial state. This article is a companion piece to this month's Design Techniques installment, which focuses on designing classes for proper initialization. Here we take an in-depth look at the mechanisms Java uses to manage object initialization.
The motivation behind Java's initialization mechanisms
At the beginning of an object's life, the Java virtual machine (JVM) allocates enough memory on the heap to accommodate the object's instance variables. When that memory is first allocated, however, the data it contains is unpredictable. If the memory were used as is, the behavior of the object would also be unpredictable. To guard against such a scenario, Java makes certain that memory is initialized, at least to predictable default values, before it is used by any code.
Initialization is important because, historically, uninitialized data has been a common source of bugs. Bugs caused by uninitialized data occur regularly in C, for example, because it doesn't have built-in mechanisms to enforce proper initialization of data. C programmers must always remember to initialize data after they allocate it and before they use it. The Java language, by contrast, has built-in mechanisms that help you ensure proper initialization of the memory occupied by a newly-created object. With proper use of these mechanisms, you can prevent an object of your design from ever being created with an invalid initial state.
The Java language has three mechanisms dedicated to ensuring proper
initialization of objects: instance initializers (also called
instance initialization blocks), instance variable
initializers, and constructors. (Instance initializers
and instance variable initializers collectively are called
"initializers.") All three mechanisms result in Java code
that is executed automatically when an object is created. When you
allocate memory for a new object with the
new operator or
newInstance() method of class
Java virtual machine will insure that initialization code is run before
you can use the newly-allocated memory. If you design your classes such
that initializers and constructors always produce a valid state for
newly-created objects, there will be no way for anyone to create and
use an object that isn't properly initialized.