Bruce Eckel’s Thinking in Java | Contents | Prev | Next |
with
the constructor
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.
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 is
the same as the name of the class. It makes sense that such a method will be
called automatically on initialization.
//: 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(); } } ///:~
Rock();
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.
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.
any method, the constructor can have arguments
to allow you to specify
how
an object is created. The above example can easily be changed so the
constructor takes an argument:
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); } }
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:
t = new Tree(12); // 12-foot tree
Tree(int)
is your only constructor, then the compiler won’t let you create a
Tree
object any other way.
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.
constructor is an unusual type of method because it has no return value.
This is distinctly different from a
void
return value, in which the method returns nothing but you still have the option
to make it return something else. Constructors return nothing and you
don’t have an option. If there were a return value, and if you could
select your own, the compiler would somehow need to know what to do with that
return value.