Guaranteed initialization with the constructor

with
the constructor

You

can imagine creating a method called

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

.

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.

The

next challenge is what to name this method. There are two issues. The first is

that any name you use could clash with a name you might like to use as a member

in the class. The second is that because the compiler is responsible for

calling the constructor, it must always know which method to call. The C++

solution seems the easiest and most logical, so it’s also used in Java:

The name of the constructor

Here’s

a simple class with a constructor: (See page

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

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

.

Like

any method, the constructor can have arguments

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

has a constructor that takes a single integer argument denoting the height of

the tree, you would create a

object like this:

If

is your only constructor, then the compiler won’t let you create a

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

method that is conceptually separate from definition. In Java, definition and

initialization are unified concepts – you can’t have one without

the other.

The

constructor is an unusual type of method because it has no return value

|

|