Guaranteed initialization with the constructor

Bruce Eckel’s Thinking in Java Contents | Prev | Next

with
the constructor

You
can imagine creating a method called
initialize( )
for every class you write. The name is a hint that it should be called before
using the object. Unfortunately, this means the user must remember to call the
method. In Java, the class designer can guarantee initialization of every
object by providing a special method called a
constructor.
If a class has a constructor, Java automatically calls that constructor when an
object is created, before users can even get their hands on it. So
initialization is guaranteed.

Here’s
a simple class with a constructor: (See page
97
if you have trouble executing this program.)

//: SimpleConstructor.java
// Demonstration of a simple constructor
package c04;
 
class Rock {
  Rock() { // This is the constructor
    System.out.println("Creating Rock");
  }
}
 
public class SimpleConstructor {
  public static void main(String[] args) {
    for(int i = 0; i < 10; i++)
      new Rock();
  }
} ///:~ 

Now,
when an object
is created:

new
Rock();

storage
is allocated and the constructor is called. It is guaranteed that the object
will be properly initialized before you can get your hands on it.

Note
that the coding style of making the first letter of all methods lower case does
not apply to constructors, since the name of the constructor must match the
name of the class
exactly.

class Rock {
  Rock(int i) {
    System.out.println(
      "Creating Rock number " + i);
  }
}
 
public class SimpleConstructor {
  public static void main(String[] args) {
    for(int i = 0; i < 10; i++)
      new Rock(i);
  }
}

Constructor
arguments provide you with a way to provide parameters for the initialization
of an object. For example, if the class
Tree
has a constructor that takes a single integer argument denoting the height of
the tree, you would create a
Tree
object like this:

Tree
t = new Tree(12); // 12-foot tree

If
Tree(int)
is your only constructor, then the compiler won’t let you create a
Tree
object any other way.

Constructors
eliminate a large class of problems and make the code easier to read. In the
preceding code fragment, for example, you don’t see an explicit call to
some
initialize( )
method that is conceptually separate from definition. In Java, definition and
initialization are unified concepts – you can’t have one without
the other.

More by Author

Must Read